# -*- coding: utf-8 -*-

 ###############################################
 ##                                             ##
 ##   Servicios - igu                            ##
 ##                                              ##
 ##                                              ##
 ##                                              ##
 ##   por Críptidos Digitales                    ##
 ##   GPL (c)2008                                ##
  ##                                             ##
    ###############################################


from decimal import Decimal as dec
from PyQt4 import QtCore, QtGui

from cdWidgets import cdFrame

import utilities
import frame_ui
import administradorServicios_ui as administrador_ui
import capturaServicio_ui as captura_ui
import detallesServicio_ui as detalles_ui
import recepcion_ui
import diagnostico_ui
import presupuesto_ui
import venta_ui
import pagos_ui

from personas import selector as selectorCliente

import manejador


class Forma(cdFrame.CDFrame):

    @property
    def app(self):
        return self.__app

    @property
    def modo(self):
        return self.__modo

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds):
        if kwds.has_key('app'):
            self.__app = kwds.pop('app')
            manejador.app = self.__app
        else:
            self.__app = None

        if 'modo' in kwds.keys():
            self.__modo = kwds.pop('modo')
        else:
            self.__modo = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = frame_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.frame1.close()
        self.ui.frame2.close()
        self.ui.frame3.close()

        self.modificacionHabilitada = True
        if self.modo==u'consulta':
            self.modificacionHabilitada = False

        ## Detalles
        self.detalles = Detalles(self, owner=self)
        self.detalles.hide()

        ## Captura
        self.captura = Captura(self, owner=self, app=self.app)
        self.connect(self.captura, QtCore.SIGNAL('capturaClosed()'), self.capturaClosed)
        self.connect(self.captura, QtCore.SIGNAL("serviciosChanged()"), self.serviciosChanged)

        ## Administrador
        self.administrador = Administrador(self, owner=self)
        self.connect(self.administrador, QtCore.SIGNAL("serviciosChanged()"), self.serviciosChanged)

        self.ui.outerSplitter = Splitter(QtCore.Qt.Vertical, self)

        self.ui.innerSplitter = Splitter(QtCore.Qt.Horizontal, self.ui.outerSplitter)

        self.ui.verticalLayout.addWidget(self.ui.outerSplitter)

        self.ui.innerSplitter.insertWidget(0, self.administrador)
        self.ui.innerSplitter.insertWidget(1, self.detalles)
        self.connect(self.ui.innerSplitter.handle(1), QtCore.SIGNAL("handlePressed"), self.innerHandlePressed)

        self.ui.outerSplitter.insertWidget(0, self.ui.innerSplitter)
        self.ui.outerSplitter.insertWidget(1, self.captura)
        self.connect(self.ui.outerSplitter.handle(1), QtCore.SIGNAL('handlePressed'), self.outerHandlePressed)

        if self.modo==u'consulta':
            self.captura.hide()
            self.administrador.ui.toAgregar.hide()
            self.administrador.menuTablaConsulta.removeAction(self.administrador.aAgregar)
        else:
            self.administrador.hide()
            self.administrador.aEliminar.setEnabled(False)
            self.captura.agrega()

        # self.connect(self.parent(), QtCore.SIGNAL("clientesChangedBroadcast()"), self.clientesChangedBroadcast)
        self.connect(self.parent(), QtCore.SIGNAL("empleadosChangedBroadcast()"), self.empleadosChangedBroadcast)
        self.connect(self.parent(), QtCore.SIGNAL("equiposChangedBroadcast()"), self.equiposChangedBroadcast)
        self.connect(self.parent(), QtCore.SIGNAL('serviciosChangedBroadcast()'), self.serviciosChangedBroadcast)
        # self.connect(self.parent(), QtCore.SIGNAL("proveedoresChangedBroadcast()"), self.proveedoresChangedBroadcast)

        # self.ui.innerSplitter.setStretchFactor(0, 1)

        # self.ui.innerSplitter.setSizes([1, 0])

        self.impresor = QtGui.QPrinter()


    def innerHandlePressed(self):
        self.administrador.toggleDetalles()

    def outerHandlePressed(self):       # print "servicios.igu.Forma.outerHandlePressed()"
        if self.ui.outerSplitter.sizes()[0]:
            self.ui.outerSplitter.setSizes([0, 1])
        else:
            self.ui.outerSplitter.setSizes([1, 1])

    def capturaClosed(self):            # print "servicios.igu.Forma.capturaClosed()"
        self.setInnerStatus("visible")
        self.administrador.actualizaBotones()

    # def clasificacionesChanged(self):
        # print "productos.igu.forma.clasificacionesChanged()"
        # self.emit(QtCore.SIGNAL("clasificacionesChanged()"))

    # def clientesChangedBroadcast(self):
        # self.emit(QtCore.SIGNAL('clientesChangedBroadcast()'))

    def empleadosChangedBroadcast(self):# print "servicios.igu.forma.empleadosChangedBroadcast()"
        self.emit(QtCore.SIGNAL("empleadosChangedBroadcast()"))

    def equiposChangedBroadcast(self):  # print "servicios.igu.forma.equiposChangedBroadcast()"
        self.emit(QtCore.SIGNAL("equiposChangedBroadcast()"))


    def imprime(self, documento=None):
        m = "ventas.igu.Forma.imprime()"

        dialogoImpresora = QtGui.QPrintDialog(self.impresor)
        if dialogoImpresora.exec_() == QtGui.QDialog.Accepted:

            painter = QtGui.QPainter(self.impresor)

            procesoServicioZero = [x for x in documento.operacion.procesos if x.tipo==u'servicio']
            if procesoServicioZero:
                servicio = [x.documentos[0].servicio for x in procesoServicioZero[0].operaciones if x.tipo==u'recepción'][0]

            ## LISTA FILTRADA
            if documento is None:
                font = QtGui.QFont()
                font.setBold(True)
                font.setPointSize(10)
                font.setFamily('courier')

                painter.setFont(font)

                margenHorizontal, margenVertical = [10, 10]
                margenX, margenY = [25, 75]
                pageNo = 1
                contenido = []

                ## Header
                # Nombre de documento
                x,y = [ 20, 20]; contenido.append([margenX+x, margenY+y, u"Listado de Ventas"])
                # Fecha
                x,y = [528, 20]; contenido.append([margenX+x, margenY+y, u"%s" % datetime.datetime.today().strftime('%d de %B de %Y')])
                # Labels
                x,y = [ 25, 90]; contenido.append([margenX+x, margenY+y, u"Documento"])
                x,y = [140, 90]; contenido.append([margenX+x, margenY+y, u"Fecha"])
                x,y = [245, 90]; contenido.append([margenX+x, margenY+y, u"Monto"])
                x,y = [330, 90]; contenido.append([margenX+x, margenY+y, u"Status"])
                x,y = [435, 90]; contenido.append([margenX+x, margenY+y, u"Cliente"])

                x,y = [  0,120]
                offset = 0

                tabla = self.administrador.ui.tablaConsulta
                for rowIndex in range(tabla.rowCount()):
                    proceso = manejador.dameProceso(id=tabla.item(rowIndex, 0).data(QtCore.Qt.UserRole).toInt()[0])
                    documentoX = ([xx for xx in proceso.operaciones if xx.tipo==u'salida'][0]).documentos[0]
                    contenido.append([margenX+x+ 20, margenY+y+offset, "%s %s" % (documentoX.tipo.nombre.capitalize(), documentoX.folio)])
                    contenido.append([margenX+x+135, margenY+y+offset, documentoX.fecha.strftime("%d-%b-%Y")])
                    contenido.append([margenX+x+250, margenY+y+offset, "%s" % documentoX.total])
                    contenido.append([margenX+x+330, margenY+y+offset, documentoX.status])
                    contenido.append([margenX+x+420, margenY+y+offset, "%s %s" % (documentoX.rol.entidad.nombre, documentoX.rol.entidad.nombre2)])
                    offset += 25


            ## Documento 1 (Factura)
            elif documento.tipo.nombre == u'factura':

                font = QtGui.QFont()
                font.setBold(True)
                font.setPointSize(10)
                font.setFamily('courier')

                painter.setFont(font)

                margenX, margenY = [35, 85]

                pageNo = 1
                contenido = []

                # if self.app.config.pull('format', 'factura'):

                format = file("propio/factura.txt").read()
                formatList = format.replace("\n\n", "\n").replace("\n\n", "\n").split("\n")
                format = [(x.split(",")) for x in formatList]

                format = dict([(x[0], [int(y) for y in x[1:] if y]) for x in format if x[0][0]!="#"])

                # Folio
                painter.drawText(QtCore.QPoint(margenX+format['folio'][0], margenY+format['folio'][1]), documento.folio)

                # Fecha
                painter.drawText(QtCore.QPoint(margenX+format['fecha'][0], margenY+format['fecha'][1]), documento.fecha.strftime('%d de %B de %Y'))

                # Nombre
                painter.drawText(QtCore.QPoint(margenX+format['nombre'][0], margenY+format['nombre'][1]), u"%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))

                # Calle y colonia
                painter.drawText(QtCore.QPoint(margenX+format['direccion'][0], margenY+format['direccion'][1]), u"%s %s" % (documento.rol.direcciones[0].calle, documento.rol.direcciones[0].areanominal))

                # CP y Lugar
                painter.drawText(QtCore.QPoint(margenX+format['lugar'][0], margenY+format['lugar'][1]), u"CP %s   %s" % (documento.rol.direcciones[0].areapostal, documento.rol.direcciones[0].lugar.nombre))

                # RFC
                painter.drawText(QtCore.QPoint(margenX+format['rfc'][0], margenY+format['rfc'][1]), documento.rol.entidad.rfc)

                if procesoServicioZero:
                    # Código
                    painter.drawText(QtCore.QPoint(margenX+format['economico'][0], margenY+format['economico'][1]), servicio.equipo.codigo)

                    # Marca
                    painter.drawText(QtCore.QPoint(margenX+format['marca'][0], margenY+format['marca'][1]), "%s %s" % (servicio.equipo.marca.nombre, servicio.equipo.linea.nombre))

                    painter.drawText(QtCore.QPoint(margenX+formet['serie'][0], margenY+format['serie'][1]), "Serie %s" % servicio.equipo.serie)

                    # Modelo
                    painter.drawText(QtCore.QPoint(margenX+format['modelo'][0], margenY+format['modelo'][1]), servicio.equipo.modelo.nombre)

                    # Registro
                    painter.drawText(QtCore.QPoint(margenX+format['placa'][0], margenY+format['placa'][1]), servicio.equipo.registro)

                    # Nivel 2
                    painter.drawText(QtCore.QPoint(margenX+format['odometro'][0], margenY+format['odometro'][1]), servicio.nivel2)

                x, y = format['partidas']
                offset = 0

                for partida in documento.partidas:
                    acepcion = manejador.dameAcepcion(producto_id=partida.producto_id, rol_id=self.app.holder.id)

                    painter.drawText(QtCore.QPoint(margenX+format['cantidad'][0], margenY+y+offset), "%s" % partida.cantidad)
                    painter.drawText(QtCore.QPoint(margenX+format['codigo'][0], margenY+y+offset), acepcion.codigo)
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0], margenY+y+offset), acepcion.nombre)
                    painter.drawText(QtCore.QPoint(margenX+format['linea'][0], margenY+y+offset), acepcion.producto.lineas[0].nombre)
                    painter.drawText(QtCore.QPoint(margenX+format['importe'][0], margenY+y+offset), "%8.2f" % (partida.cantidad * partida.precio))
                    offset += 20

                # Cantidad con letra
                painter.drawText(QtCore.QPoint(margenX+format['cantidadconletra'][0], margenY+format['cantidadconletra'][1]), "(%s M.N.)" % utilities.moneyToText(documento.total.quantize(dec('0.01'))))

                # Subtotal
                painter.drawText(QtCore.QPoint(margenX+format['subtotal'][0], margenY+format['subtotal'][1]), "%8.2f" % documento.subtotal)

                painter.drawText(QtCore.QPoint(margenX+format['impuesto'][0], margenY+format['impuesto'][1]), "%8.2f" % documento.impuesto)

                painter.drawText(QtCore.QPoint(margenX+format['total'][0], margenY+format['total'][1]), "%8.2f" % documento.total)

                # Pagaré
                if len(format['pagare.total']) == 4:
                    font.setPointSize(10)
                    painter.setFont(font)
                painter.drawText(QtCore.QPoint(margenX+format['pagare.total'][0], margenY+format['pagare.total'][1]), "%8.2f" % documento.total)
                painter.drawText(QtCore.QPoint(margenX+format['pagare.total'][0], margenY+format['pagare.total'][1]), "(%s M.N.)" % utilities.moneyToText(documento.total.quantize(dec('0.01'))))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.fecha'][0], margenY+format['pagare.fecha'][1]), documento.fecha.strftime('%d de %B de %Y'))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.interes'][0], margenY+format['pagare.interes'][1]), "10")
                painter.drawText(QtCore.QPoint(margenX+format['pagare.nombre'][0], margenY+format['pagare.nombre'][1]), u"%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.direccion'][0], margenY+format['pagare.direccion'][1]), u"%s %s %s %s" % (documento.rol.direcciones[0].calle, documento.rol.direcciones[0].areanominal, documento.rol.direcciones[0].areapostal, documento.rol.direcciones[0].lugar.nombre))
                painter.drawText(QtCore.QPoint(margenX+format['pagare.fecha'][0], margenY+format['pagare.fecha'][1]), documento.fecha.strftime('%d de %B de %Y'))



            ## DOCUMENTO 2 (REMISIÓN)
            elif documento.tipo.nombre == u'remisión':

                font = QtGui.QFont()
                font.setBold(True)
                font.setPointSize(10)
                font.setFamily('courier')

                painter.setFont(font)

                margenX, margenY = [35, 35]
                pageNo = 1
                contenido = []

                formatList = file("propio/remision.txt").read()
                formatList = formatList.replace("\n\n", "\n").replace("\n\n", "\n").replace("\n\n", "\n").split("\n")
                format = {}
                for item in formatList:
                    if item and item != ' ':
                        items = item.split(" , ")
                        if items[0][0] != "#":
                            items[1] = int(items[1])
                            items[2] = int(items[2])
                            format[items[0]] = items[1:]

                # Logo
                painter.drawPixmap(QtCore.QPoint(margenX, margenY), QtGui.QPixmap("propio/logo.jpg"))

                # Folio
                painter.drawText(QtCore.QPoint(margenX+format['folio'][0]+30, margenY+format['folio'][1]-25), u"REMISIÓN")
                painter.drawText(QtCore.QPoint(margenX+format['folio'][0]+40, margenY+format['folio'][1]), documento.folio)

                # Fecha
                painter.drawText(QtCore.QPoint(margenX+format['fecha'][0]+40, margenY+format['fecha'][1]-25), u"FECHA")
                painter.drawText(QtCore.QPoint(margenX+format['fecha'][0], margenY+format['fecha'][1]), documento.fecha.strftime('%d de %B de %Y'))

                # Cliente Nombre
                painter.drawText(QtCore.QRectF(margenX+format['cliente.nombre'][0]-125, margenY+format['cliente.nombre'][1], 100, 30), u"Cliente", QtGui.QTextOption(QtCore.Qt.AlignRight))

                painter.drawText(QtCore.QRectF(margenX+format['cliente.nombre'][0],  margenY+format['cliente.nombre'][1], margenX+format['cliente.nombre'][0]+400, margenY+format['cliente.nombre'][1]), u"%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))

                if procesoServicioZero:
                    # Vehiculo
                    painter.drawText(QtCore.QRectF(margenX+format['vehiculo.descripcion'][0]-100, margenY+format['vehiculo.descripcion'][1], 100, 30), u"Vehículo", QtGui.QTextOption(QtCore.Qt.AlignRight))

                    painter.drawText(QtCore.QPoint(margenX+format['vehiculo.descripcion'][0], margenY+format['vehiculo.descripcion'][1]), "%s %s %s %s %s" % (servicio.equipo.codigo, servicio.equipo.marca.nombre, servicio.equipo.linea.nombre, servicio.equipo.modelo.nombre, servicio.equipo.registro))

                # Partidas
                x, y = format['partidas']
                offset = 0

                painter.drawText(QtCore.QPoint(margenX+10, margenY+y-35), u"CANTIDAD")
                painter.drawText(QtCore.QPoint(margenX+190, margenY+y-35), u"CONCEPTO")
                painter.drawText(QtCore.QPoint(margenX+610, margenY+y-35), u"IMPORTE")

                for partida in documento.partidas:
                    acepcion = manejador.dameAcepcion(producto_id=partida.producto_id, rol_id=self.app.holder.id)
                    painter.drawText(QtCore.QPoint(margenX+format['cantidad'][0], margenY+y+offset), "%s" % partida.cantidad)
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0], margenY+y+offset), acepcion.codigo)
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0]+90, margenY+y+offset), acepcion.nombre)
                    painter.drawText(QtCore.QPoint(margenX+format['descripcion'][0]+290, margenY+y+offset), acepcion.producto.clasificacion.nombre)
                    # contenido.append([margenX+x+600, margenY+y+offset, "%.2f" % partida.precio])
                    painter.drawText(QtCore.QRectF(margenX+format['importe'][0], margenY+y+offset-10, 115, 20), "%8.2f" % (partida.cantidad * partida.precio), QtGui.QTextOption(QtCore.Qt.AlignRight))
                    offset += 20

                # Cantidad con letras
                painter.drawText(QtCore.QPoint(margenX+format['cantidadconletra'][0], margenY+format['cantidadconletra'][1]), "(%s M.N.)" % utilities.moneyToText(documento.total.quantize(dec('0.01'))))

                # Total
                painter.drawText(QtCore.QRectF(margenX+format['total'][0]-100, margenY+format['total'][1]+5, 100, 20), u"Total", QtGui.QTextOption(QtCore.Qt.AlignRight))

                painter.drawText(QtCore.QRectF(margenX+format['total'][0], margenY+format['total'][1]+5, 115, 20), "%8.2f" % documento.subtotal, QtGui.QTextOption(QtCore.Qt.AlignRight))

                # PAGARÉ
                painter.drawText(QtCore.QRectF(margenX+format['pagare.texto'][0]+10, margenY+format['pagare.texto'][1]+10, margenX+format['pagare.texto'][0]+660, margenY+format['pagare.texto'][1]+180), (format['pagare.texto'][2] % (u"%8.2f" % documento.subtotal, documento.fecha.strftime('%d de %B de %Y'), unicode("%s %s", "latin1") % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2), u"", documento.fecha.strftime('%d de %B de %Y'))).replace(u'[LF]', u'\n'))

                pen = painter.pen()
                pen.setWidth(2)
                painter.setPen(pen)

                # MARCO FOLIO
                painter.drawRect(QtCore.QRect(margenX+format['folio'][0]-20, margenY+format['folio'][1]-40, 175, 20))
                painter.drawRect(QtCore.QRect(margenX+format['folio'][0]-20, margenY+format['folio'][1]-20, 175, 30))

                # Marco Fecha
                painter.drawRect(QtCore.QRect(margenX+format['fecha'][0]-20, margenY+format['fecha'][1]-40, 175, 20))
                painter.drawRect(QtCore.QRect(margenX+format['fecha'][0]-20, margenY+format['fecha'][1]-20, 175, 30))

                # Marco Labels
                painter.drawRect(QtCore.QRect(margenX, margenY+y-50, 700, 25))  # Labels

                # Marco Total
                painter.drawRect(QtCore.QRect(margenX+format['total'][0]+25, margenY+format['total'][1], 100, 30))

                # Marco pagaré
                painter.drawRect(QtCore.QRect(margenX+format['pagare.texto'][0], margenY+format['pagare.texto'][1], 700, 200))

                for marco in [format[x] for x in format.keys() if 'marco' in x]:
                    painter.drawRect(margenX+marco[0], margenY+marco[1], int(marco[2]), int(marco[3]))


    def serviciosChanged(self):
        self.emit(QtCore.SIGNAL('serviciosChanged()'))

    def serviciosChangedBroadcast(self):
        self.emit(QtCore.SIGNAL('serviciosChangedBroadcast()'))

    def setInnerStatus(self, value):    # print "ventas.igu.Forma.setInnerStatus(%s)" % value
        if value == 'visible':
            self.administrador.show()
            if self.detalles.status == 'hidden':
                self.detalles.show()
                self.detalles.status = "normal"

        elif value == 'hidden':
            self.administrador.hide()
            if self.detalles.isVisible():
                self.detalles.status = "hidden"
                self.detalles.hide()

        elif value == 'disabled':
            print 'disables'


class Administrador(cdFrame.CDFrame):

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds):
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = administrador_ui.Ui_Form()
        self.ui.setupUi(self)

        ## TABLA DE CONSULTA
        self.ui.tablaConsulta.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.ui.tablaConsulta.setStyleSheet("background-color:#FFFFFF;")
        self.ui.tablaConsulta.setColumnCount(5)
        self.ui.tablaConsulta.setHorizontalHeaderLabels([u"Folio", u"Fecha", u"Estado", u"Cliente", u"Equipo"])
        self.ui.tablaConsulta.horizontalHeader().setResizeMode(3, QtGui.QHeaderView.Stretch)
        self.ui.tablaConsulta.horizontalHeader().setResizeMode(4, QtGui.QHeaderView.Stretch)
        self.ui.tablaConsulta.verticalHeader().setVisible(False)

        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.toggleDetalles)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemSelectionChanged()"), self.selectionChanged)
        # self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("currentItemChanged(QTableWidgetItem *,QTableWidgetItem *)"), self.currentChanged)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)

        ## Agregar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aAgregar = QtGui.QAction(icon, u"&Agregar", self)
        self.aAgregar.setCheckable(True)
        self.aAgregar.setIconText(u"&Agregar")
        self.connect(self.aAgregar, QtCore.SIGNAL("triggered()"), self.agrega)
        self.ui.toAgregar.setDefaultAction(self.aAgregar)
        self.ui.toAgregar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toAgregar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Modificar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aModificar = QtGui.QAction(icon, u"&Modificar", self)
        self.aModificar.setCheckable(True)
        self.aModificar.setIconText(u"&Modificar")
        self.connect(self.aModificar, QtCore.SIGNAL("triggered()"), self.modifica)

        self.ui.toModificar.setDefaultAction(self.aModificar)
        self.ui.toModificar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toModificar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## ELIMINAR
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Minus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aEliminar = QtGui.QAction(icon, u"&Eliminar", self)
        self.aEliminar.setCheckable(True)
        self.aEliminar.setIconText(u"&Eliminar")
        self.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.elimina)
        self.ui.toEliminar.setDefaultAction(self.aEliminar)
        self.ui.toEliminar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toEliminar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## ESTADOS
        statuss = manejador.dameStatuss()
        self.ui.chStatuss = {}
        for status in statuss:
            self.ui.chStatuss[str(status.valor)] = QtGui.QCheckBox(self.ui.frStatus)
            self.ui.chStatuss[str(status.valor)].setText(status.valor)
            self.ui.chStatuss[str(status.valor)].setChecked(True)
            self.ui.lyStatus.addWidget(self.ui.chStatuss[str(status.valor)])
            self.connect(self.ui.chStatuss[str(status.valor)], QtCore.SIGNAL('stateChanged(int)'), self.chChanged)

        ## CLIENTE
        self.connect(self.ui.cbCliente, QtCore.SIGNAL('currentIndexChanged(int)'), self.clienteSeleccionado)
        # completer = QtGui.QCompleter([], self.ui.edCliente)
        # completer.setModel(Modelo(self))
        # completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        # self.ui.edCliente.setCompleter(completer)
        # self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.clienteSeleccionado)
        # self.connect(self.ui.edCliente, QtCore.SIGNAL('downArrowPressed()'), self.muestraClientes)

        self.cargaClientes()
        # self.ui.edCliente.setText(manejador.dameClienteDefault().valor)

        ## TECNICO
        self.connect(self.ui.cbTecnico, QtCore.SIGNAL('currentIndexChanged(int)'), self.tecnicoSeleccionado)
        # completer = QtGui.QCompleter([], self.ui.edTecnico)
        # completer.setModel(Modelo(self))
        # completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        # self.ui.edTecnico.setCompleter(completer)
        # self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.tecnicoSeleccionado)
        # self.connect(self.ui.edTecnico, QtCore.SIGNAL('downArrowPressed()'), self.muestraTecnicos)

        self.cargaTecnicos()
        # self.ui.edTecnico.setText(manejador.dameTecnicoDefault().valor)

        ## MENU DE CONTEXTO DE TABLA DE CONSULTA
        self.menuTablaConsulta = QtGui.QMenu(self)
        self.menuTablaConsulta.addAction(self.aAgregar)
        self.menuTablaConsulta.addAction(self.aModificar)
        self.menuTablaConsulta.addAction(self.aEliminar)

        self.connect(self.parent(), QtCore.SIGNAL("serviciosChangedBroadcast()"), self.actualizaConsulta)

        #! Falta cachar broadcast de cliente

        self.actualizaConsulta()


    def actualizaBotones(self):
        if not self.owner.modificacionHabilitada:
            self.aModificar.setEnabled(False)
            self.aModificar.setToolTip(u"La modificación de Servicios no está implementada\nContacte al proveedor del sistema")


        self.aAgregar.setEnabled(True)
        self.aAgregar.setToolTip(u"Presiona para registrar un Servicio nuevo")

        if not self.owner.captura.isVisible():
            self.aAgregar.setChecked(False)
            self.aModificar.setChecked(False)
        self.aEliminar.setChecked(False)

        if self.ui.tablaConsulta.selectedItems():
            if self.owner.modificacionHabilitada:
                self.aModificar.setEnabled(True)
                self.aModificar.setToolTip(u"Presiona para modificar los datos del Servicio seleccionado")
            self.aEliminar.setEnabled(True)
            self.aEliminar.setToolTip(u"Presiona para eliminar el Servicio seleccionado")
        else:
            if self.owner.modificacionHabilitada:
                self.aModificar.setEnabled(False)
                if self.ui.tablaConsulta.rowCount() > 0:
                    self.aModificar.setToolTip(u"Selecciona el Servicio que quieres Modificar")
                else:
                    self.aModificar.setToolTip(u"No hay Servicios registrados")


            self.aEliminar.setEnabled(False)
            if self.ui.tablaConsulta.rowCount() > 0:
                self.aEliminar.setToolTip(u"Selecciona el Servicio que quieres Eliminar")
            else:
                self.aEliminar.setToolTip(u"No hay Servicios registrados")

        self.ui.toEliminar.setVisible(False)
        self.aEliminar.setVisible(False)


    def actualizaConsulta(self):        # print "servicios.igu.Administrador.actualizaConsulta()"
        filtros = {}

        if self.ui.cbCliente.currentIndex() > 0:
            filtros['cliente_id'] = self.ui.cbCliente.itemData(self.ui.cbCliente.currentIndex()).toInt()[0]

        if self.ui.cbTecnico.currentIndex() > 0:
            filtros['tecnico_id'] = self.ui.cbTecnico.itemData(self.ui.cbTecnico.currentIndex()).toInt()[0]

        for status in self.ui.chStatuss.keys():
            if self.ui.chStatuss[status].isChecked():
                filtros[str(status)] = ""

        procesos = manejador.dameVarios(**filtros)

        self.ui.tablaConsulta.setRowCount(len(procesos))

        self.ui.tablaConsulta.setSortingEnabled(False)

        for index, proceso in enumerate(procesos):

            docServicio = proceso.operaciones[0].documentos[0]

            item = QtGui.QTableWidgetItem("%s" % docServicio.folio)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignCenter)
            item.setData(1000, QtCore.QVariant(proceso.id))
            self.ui.tablaConsulta.setItem(index, 0, item)

            if docServicio.fecha is not None:
                item = QtGui.QTableWidgetItem(docServicio.fecha.strftime("%d %b %Y"))
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignCenter)
                self.ui.tablaConsulta.setItem(index, 1, item)

            item = QtGui.QTableWidgetItem(docServicio.status)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignCenter)
            self.ui.tablaConsulta.setItem(index, 2, item)

            item = QtGui.QTableWidgetItem("%s %s" % (docServicio.rol.entidad.nombre, docServicio.rol.entidad.nombre2))
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaConsulta.setItem(index, 3, item)

            item = QtGui.QTableWidgetItem("%s %s %s" % (docServicio.servicio.equipo.marca.nombre, docServicio.servicio.equipo.linea.nombre, docServicio.servicio.equipo.modelo.nombre))
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaConsulta.setItem(index, 4, item)

        self.ui.tablaConsulta.setSortingEnabled(True)

        self.actualizaBotones()


    def agrega(self):
        self.owner.ui.outerSplitter.setSizes([0, 1])
        self.owner.captura.agrega()


    def chChanged(self, state):
        m = "servicios.igu.Administrador.chChanged()"

        self.actualizaConsulta()


    def clienteSeleccionado(self, index):# print "servicios.igu.Administrador.clienteSeleccionado()"
        self.actualizaConsulta()


    def cargaClientes(self):            # print "servicios.igu.Administrador.cargaClientes()"
        clientes = manejador.dameClientesDeServicio()

        self.ui.cbCliente.clear()
        self.ui.cbCliente.addItem("Todos", QtCore.QVariant(-1))
        for index, cliente in enumerate(clientes):
            self.ui.cbCliente.addItem("%s %s" % (cliente.entidad.nombre, cliente.entidad.nombre2), QtCore.QVariant(cliente.id))


    def tecnicoSeleccionado(self, index):# print "servicios.igu.Administrador.tecnicoSeleccionado()"
        self.actualizaConsulta()


    def cargaTecnicos(self):            # print "servicios.igu.Administrador.cargaTecnicos()"
        tecnicos = manejador.dameTecnicos()
        self.ui.cbTecnico.clear()
        self.ui.cbTecnico.addItem("Todos", QtCore.QVariant(-1))
        for index, tecnico in enumerate(tecnicos):
            self.ui.cbTecnico.addItem("%s %s" % (tecnico.entidad.nombre, tecnico.entidad.nombre2), QtCore.QVariant(tecnico.id))


    # def currentChanged(self, new, old): # print "servicios.igu.Administrador.currentChanged()"
        # if new and not old:
            # self.toggleDetalles()


    def equipoSelected(self, id):
        dato = self.owner.bd.get("equipos", {'equipo_id':id})
        self.ui.pbEquipo.setText("%s %s %s %s" % (dato['tipo'], dato['marca'], dato['linea'], dato['modelo']))
        self.ui.pbEquipo.id = id


    def elimina(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar orden", u"Selecciona el ORDEN que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            datos = manejador.dameUno(id=id)
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar orden", u"¿Realmente quieres ELIMINAR la ORDEN %s?" % dato.folio, QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                manejador.elimina(id=id)
                self.emit(QtCore.SIGNAL("serviciosChanged()"))


    def modifica(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Modificar orden de servicio", u"Selecciona la ORDEN DE SERVICIO que quieres MODIFICAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            self.owner.captura.modifica(id)


    def mostrarDetalles(self, item):
        id = self.ui.tablaConsulta.item(item.row(), 0).data(1000).toInt()[0]
        self.owner.detalles.mostrar(id)
        self.owner.ui.innerSplitter.setSizes([1, 1])

    def mostrarMenuConsulta(self, pos):
        pos = self.ui.tablaConsulta.mapToGlobal(pos)
        self.menuTablaConsulta.popup(pos)

    def muestraClientes(self):
        self.ui.edCliente.completer().setCompletionPrefix(self.ui.edCliente.text())
        self.ui.edCliente.completer().complete()

    def muestraTecnicos(self):
        m = "servicios.igu.Administrador.muestraTecnicos()"
        self.ui.edTecnico.completer().setCompletionPrefix(self.ui.edTecnico.text())
        self.ui.edTecnico.completer().complete()

    def selectionChanged(self):         # print "servicios.igu.Administrador.selectionChanged()"
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            if self.owner.detalles.isVisible():
                self.owner.detalles.mostrar(id)
            if self.owner.captura.isVisible():
                if self.owner.captura.modo == 'modificar':
                    if self.owner.captura.id != id:
                        if self.owner.captura.estaModificado():
                            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Modificación de Servicio", u"La captura de Servicio tiene cambios\n\n¿Quieres Guardar los cambios para %s %s %s?" % (self.owner.captura.old.tipo, self.owner.captura.old.folio, self.owner.captura.old.fecha), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)

                            if result == QtGui.QMessageBox.Yes:
                                self.owner.captura.guarda()
                        self.owner.captura.modifica(id)
        self.actualizaBotones()

    def toggleDetalles(self, *args):
        m = "servicios.igu.Administrador.toggleDetalles()"

        if self.owner.ui.innerSplitter.sizes()[1]:
            self.owner.detalles.hide()
            self.owner.detalles.status = 'closed'
            self.owner.ui.innerSplitter.setSizes([1, 0])
        else:
            if self.ui.tablaConsulta.currentRow() != -1:
                id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
                data = manejador.dameUno(id=id)
                self.owner.detalles.setData(data)
                self.owner.detalles.show()
                self.owner.detalles.status = 'open'
                self.owner.ui.innerSplitter.setSizes([1, 100])

                # self.owner.detalles.mostrar(id)
                # self.owner.ui.innerSplitter.setSizes([1, 100])



class Captura(cdFrame.CDFrame):

    @property
    def app(self):
        return self.__app

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds):  # print "servicios.igu.Captura.__init__()"
        if kwds.has_key('app'):
            self.__app = kwds.pop('app')
        else:
            self.__app = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        self.__modo = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = captura_ui.Ui_Form()
        self.ui.setupUi(self)

        ## Rangos de precio activos
        self.cargaRangosPrecioActivos()

        self.connect(self.ui.edFolio, QtCore.SIGNAL('editingFinished()'), self.folioChanged)

        ## RECEPCION
        self.recepcion = Recepcion(self, owner=self)
        self.ui.layoutRecepcion.addWidget(self.recepcion)
        self.connect(self.recepcion, QtCore.SIGNAL('statusChanged()'), self.actualizaStatus)

        ## DIAGNÓSTICO
        self.ui.diagnostico = Diagnostico(self, owner=self)
        self.ui.layoutDiagnostico.addWidget(self.ui.diagnostico)
        self.connect(self.ui.diagnostico, QtCore.SIGNAL('statusChanged()'), self.actualizaStatus)
        # self.connect(self.ui.diagnostico, QtCore.SIGNAL('actualizaStatus()'), self.actualizaStatus)

        ## PRESUPUESTO
        self.ui.presupuesto = Presupuesto(self, owner=self)
        self.ui.layoutPresupuesto.addWidget(self.ui.presupuesto)
        self.connect(self.ui.presupuesto, QtCore.SIGNAL('edited()'), self.actualizaStatus)
        # self.connect(self.ui.presupuesto, QtCore.SIGNAL('statusChanged()'), self.actualizaStatus)

        ## VENTA
        self.ui.venta = Venta(self, owner=self)

        # spacerItem = QtGui.QSpacerItem(40, 0, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
        # self.ui.layoutVenta.addItem(spacerItem)
        self.ui.label = QtGui.QLabel()
        self.ui.label.setAlignment(QtCore.Qt.AlignCenter)
        self.ui.label.setStyleSheet("color:#FF0000;")
        self.ui.layoutVenta.addWidget(self.ui.label)

        # spacerItem = QtGui.QSpacerItem(40, 0, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
        # self.ui.layoutVenta.addItem(spacerItem)
        self.ui.layoutVenta.addWidget(self.ui.venta)

        self.connect(self.ui.venta, QtCore.SIGNAL('statusChanged()'), self.actualizaStatus)


        self.ui.boGuardar.setDefault(True)
        self.ui.boGuardar.setEnabled(False)

        self.connect(self.ui.boGuardar, QtCore.SIGNAL("clicked()"), self.guarda)
        self.connect(self.ui.boCancelar, QtCore.SIGNAL("clicked()"), self.cancela)

        self.connect(self.parent(), QtCore.SIGNAL('clientesChangedBroadcast()'), self.recepcion.ui.selectorCliente.cargaNombres)
        self.connect(self.parent(), QtCore.SIGNAL('clientesChangedBroadcast()'), self.ui.venta.ui.selectorCliente.cargaNombres)
        self.connect(self.parent(), QtCore.SIGNAL("empleadosChangedBroadcast()"), self.empleadosChangedBroadcast)
        self.connect(self.parent(), QtCore.SIGNAL("equiposChangedBroadcast()"), self.recepcion.cargaEquipos)

        self.connect(self, QtCore.SIGNAL('showed()'), self.showed)

        self.setTabOrder(self.ui.tabWidget, self.ui.boGuardar)
        self.setTabOrder(self.ui.boGuardar, self.ui.boCancelar)

        self.rol = None
        self.proceso = None

        self.agrega()


    def empleadosChangedBroadcast(self):# print "servicios.igu.Captura.empleadosChangedBroadcast()"
        self.emit(QtCore.SIGNAL("empleadosChangedBroadcast()"))


    def actualizaStatus(self):
        if self.modo == u"modificar":
            if self.esValida():
                if self.estaModificado():
                    self.ui.boGuardar.setEnabled(True)
                    self.ui.boGuardar.setToolTip(u"")
                else:
                    self.ui.boGuardar.setEnabled(False)
                    self.ui.boGuardar.setToolTip(u"No hay cambios")
            else:
                if self.estaModificado():
                    # if not u"Recepción" in self.mensajes2:
                        # self.ui.boGuardar.setEnabled(True)
                    # else:
                    self.ui.boGuardar.setEnabled(False)
                    self.ui.boGuardar.setToolTip("%s\n%s" % (self.mensajes, self.mensajes2))
                else:
                    self.ui.boGuardar.setEnabled(False)
                    self.ui.boGuardar.setToolTip(u"No hay cambios")

        elif self.modo == u"agregar":
            if self.esValida():
                self.ui.boGuardar.setEnabled(True)
            else:
                # if not u"Recepción" in self.mensajes:
                    # self.ui.boGuardar.setEnabled(True)
                # else:
                self.ui.boGuardar.setEnabled(False)
            self.ui.boGuardar.setToolTip(self.mensajes)


    def agrega(self):
        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "SERVICIO NUEVO", None, QtGui.QApplication.UnicodeUTF8))
        self.ui.titulo.setStyleSheet("color:#FF0000;")
        self.__modo = "agregar"
        self.clear()

        self.ui.edFolio.setText(str(manejador.dameFolio()))
        self.recepcion.ui.fecha.setDate(QtCore.QDate().currentDate())
        self.ui.diagnostico.ui.fecha.setDate(QtCore.QDate().currentDate())
        self.ui.presupuesto.ui.fecha.setDate(QtCore.QDate().currentDate())
        self.ui.venta.ui.fecha.setDate(QtCore.QDate().currentDate())

        self.ui.tabWidget.setTabEnabled(1, False)
        self.ui.tabWidget.setTabEnabled(2, False)
        self.ui.tabWidget.setTabEnabled(3, False)

        self.ui.tabWidget.setCurrentIndex(0)

        self.recepcion.ui.selectorCliente.ui.edNombre.setFocus()

        self.show()


    def cancela(self):
        self.agrega()
        # self.clear()
        # self.hide()
        # self.emit(QtCore.SIGNAL("capturaClosed()"))


    def cargaRangosPrecioActivos(self):
        rangosPrecio = manejador.rangosPrecio()
        self.__rangosPrecioActivos = []
        for index, rango in enumerate(rangosPrecio):
            if u'a' in rango.referencia:
                self.__rangosPrecioActivos.append(rango)


    def clear(self):
        self.ui.venta.clear()
        self.ui.tabWidget.setTabEnabled(3, False)
        self.ui.presupuesto.clear()
        self.ui.tabWidget.setTabEnabled(2, False)
        self.ui.diagnostico.clear()
        self.ui.tabWidget.setTabEnabled(1, False)
        self.recepcion.clear()

        self.ui.tabWidget.setCurrentIndex(0)

        self.__modo = u'agregar'

        self.actualizaStatus()


    def clienteEditado(self, texto):
        if len(texto) == 1:
            self.cargarClientes(texto)

    def datos(self, tab=None):          # print "servicios.igu.Captura.datos()"
        """ proceso: servicio
            cliente: X
            equipo: X
            documento: servicio
            documento: presupuesto
            documento: venta
            partidas: X
        """
        datos = {}

        if self.modo == u'modificar':
            datos['id'] = self.id

        ## RECEPCION
        if not tab or 'recepción' in tab:
            datos['recepción'] = self.recepcion.datos()
            datos['recepción']['folio'] = unicode(self.ui.edFolio.text())
            # datos['equipo_id'] = datos['recepcion'].pop('equipo_id')
            # if not datos['equipo_id']:
                # datos['equipo'] = datos['recepcion'].pop('equipo')

        ## DIAGNOSTICO
        if not tab or 'diagnóstico' in tab:
            if self.ui.tabWidget.isTabEnabled(1):
                datos['diagnóstico'] = self.ui.diagnostico.datos()

        ## PRESUPUESTO
        if not tab or 'presupuesto' in tab:
            if self.ui.tabWidget.isTabEnabled(2):
                datos['presupuesto'] = self.ui.presupuesto.datos()
                # datos['pedido']['rol_id'] = datos['recepcion']['cliente'].id
            # datos['pedido']['cliente_id'] = datos['recepcion']['cliente_id']

        ## VENTA
        if not tab or 'venta' in tab:
            if self.ui.tabWidget.isTabEnabled(3):
                venta = self.ui.venta.datos()
                if venta:
                    datos['venta'] = venta

        return datos


    def equipoSeleccionado(self, completerModelIndex):
        f=g

        data = self.sender().completionModel().data(completerModelIndex, QtCore.Qt.UserRole).toInt()[0]

        self.equipo = manejador.dameEquipo(id=data)

        self.ui.edCliente.setText("%s %s" % (self.equipo.propietario.nombre, self.equipo.propietario.nombre2))
        self.propietario = self.equipo.propietario

        # self.ui.edCalle.setText("%s   %s" % (self.cliente.direcciones[0].calle, self.cliente.direcciones[0].areanominal))
        # self.ui.edLugar.setText(self.cliente.direcciones[0].lugar)
        # self.ui.edRFC.setText(self.cliente.entidad.rfc)


    def estaModificado(self):
        data = self.datos()
        self.mensajes2 = u""
        modificado = False

        ## No se revisa folio, es inmutable.

        ## Recepción
        if self.recepcion.estaModificado():
            modificado = True
            self.mensajes2 += self.recepcion.mensajes2

        ## Diagnóstico
        if self.ui.diagnostico.estaModificado():
            modificado = True
            self.mensajes2 += u"Diagnóstico\n"
            self.mensajes2 += self.ui.diagnostico.mensajes2

        ## Presupuesto
        if self.ui.tabWidget.isTabEnabled(2):
            if self.ui.presupuesto.estaModificado():
                modificado = True
                self.mensajes2 += u"Presupuesto\n"
                self.mensajes2 += self.ui.presupuesto.mensajes2

        ## Venta
        if self.ui.tabWidget.isTabEnabled(3):
            if self.ui.venta.estaModificado():
                modificado = True
                self.mensajes2 += u"Venta\n"
                self.mensajes2 += self.ui.venta.mensajes2

        return modificado


    def esValida(self):
        valida = True
        self.mensajes = u""

        if not self.recepcion.esValida():
            valida = False
            self.mensajes += u"Recepción\n"
            self.mensajes += self.recepcion.mensajes
        else:
            self.ui.tabWidget.setTabEnabled(1, True)
            if not self.ui.diagnostico.esValida():
                valida = False
            if self.ui.diagnostico.mensajes:
                self.mensajes += u"Diagnóstico\n"
                self.mensajes += self.ui.diagnostico.mensajes
                self.ui.tabWidget.setTabEnabled(2, False)
            else:
                self.ui.tabWidget.setTabEnabled(2, True)
                if not self.ui.presupuesto.esValida():
                    valida = False
                if self.ui.presupuesto.mensajes:
                    self.mensajes += u"Presupuesto\n"
                    self.mensajes += self.ui.presupuesto.mensajes
                    if 'existencias' in self.ui.presupuesto.mensajes:
                        self.ui.tabWidget.setTabEnabled(3, True)
                    else:
                        self.ui.tabWidget.setTabEnabled(3, False)
                else:
                    self.ui.tabWidget.setTabEnabled(3, True)
                    self.ui.label.setVisible(False)
                    self.ui.venta.ui.boCargaPresupuesto.setEnabled(True)
                    self.ui.venta.setVisible(True)
                    self.ui.venta.ui.edFolio.setText(manejador.dameFolioVenta(self.ui.venta.ui.cbTipoDocumento.itemData(self.ui.venta.ui.cbTipoDocumento.currentIndex()).toInt()[0]))
                    if not self.ui.venta.esValida():
                        valida = False
                        # if self.ui.venta.mensajes:
                        self.mensajes += u"Venta\n"
                        self.mensajes += self.ui.venta.mensajes

        self.mensajes = unicode(self.mensajes).rstrip("\n")

        return valida


    def folioChanged(self):
        folio = unicode(self.ui.edFolio.text())
        proceso = manejador.servicioI(folio=folio)
        if proceso:
            # self.setModo(u'modificar')
            self.setData(proceso)
            self.actualizaStatus()
        else:
            self.clear()


    def guarda(self):
        # datos = self.datos()
        # if not datos['recepcion']['cliente_id']:
            # self.ui.selectorCliente.guardar()

        if self.modo == u"agregar":
            datos = self.datos('recepción')['recepción']

            proceso = manejador.recepcionI(datos)

            datos = self.datos('diagnóstico')['diagnóstico']

            if datos:
                datos['proceso'] = proceso
                manejador.agregaDiagnostico(datos)

            if self.datos('presupuesto'):
                datos = self.datos('presupuesto')['presupuesto']
                datos['proceso'] = proceso
                manejador.agregaPresupuesto(datos)

            if self.datos('venta'):
                datos = self.datos('venta')['venta']
                datos['proceso'] = proceso
                documento = manejador.agregaVenta(datos)
                if manejador.atributoI(grupo=u'venta', nombre=u'seImprimeComprobante').valor:
                    self.owner.imprime(documento)

            self.emit(QtCore.SIGNAL("serviciosChanged()"))
            self.agrega()

        elif self.modo == u"modificar":
            proceso = manejador.modifica(self.datos())

            if 'venta' in self.datos():
                if manejador.atributoI(grupo=u'venta', nombre=u'seImprimeComprobante').valor:
                    documento = [x for x in proceso.operaciones if x.tipo==u'salida'][0].documentos[0]
                    self.owner.imprime(documento)

            self.emit(QtCore.SIGNAL("serviciosChanged()"))
            self.agrega()


    def modifica(self, id):
        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Modificación de Servicio", None, QtGui.QApplication.UnicodeUTF8))
        self.ui.titulo.setStyleSheet("color:#4070C0;")
        self.clear()
        self.__modo = u"modificar"

        self.id = id
        data = manejador.dameUno(id=id)
        self.setData(data)

        self.actualizaStatus()
        self.owner.setInnerStatus('hidden')
        self.show()

        self.recepcion.ui.selectorCliente.ui.edNombre.setFocus()


    @property
    def modo(self):
        return self.__modo


    @property
    def rangosPrecioActivos(self):
        return self.__rangosPrecioActivos


    def setData(self, datos):
        ## Recepción
        documento = [x.documentos[0] for x in datos.operaciones if x.tipo==u'recepción'][0]
        self.ui.edFolio.setText(documento.folio)
        self.recepcion.setDatos(documento)

        ## Diagnóstico
        self.ui.diagnostico.setDatos(documento.servicio)

        ## Presupuesto
        documentoPresupuestoZero = [x.documentos[0] for x in datos.operaciones if x.tipo==u'solicitud']
        if documentoPresupuestoZero:
            self.ui.presupuesto.setDatos(documentoPresupuestoZero[0])
        self.ui.presupuesto.setOld(self.ui.presupuesto.datos())

        ## Venta
        documentoVentaZero = [x.documentos[0] for x in datos.operaciones if x.tipo==u'salida']
        if documentoVentaZero:
            self.ui.venta.setDatos(documentoVentaZero[0])
            self.ui.venta.setOld(self.ui.venta.datos())

        ## Pago

        documentoPagoZero = [x.documentos[0] for x in datos.operaciones if x.tipo=='cobro']
        if documentoPagoZero:
            self.ui.venta.pago.setDatos(documentoPagoZero[0])

        self.__modo = u'modificar'
        self.id = datos.id


    def setModo(self, value):
        self.__modo = value


    def showed(self):
        self.owner.owner.informacion = u""
        # self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre"





class Detalles(QtGui.QFrame):

    @property
    def owner(self):
        return self.__owner


    def __init__(self, *args, **kwds):

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = detalles_ui.Ui_Form()
        self.ui.setupUi(self)

        ## Rangos de precio activos
        self.cargaRangosPrecioActivos()

        self.ui.taPresupuesto = TablaPartidas(self, owner=self)
        labels = [u"Código", u"Nombre", u"Línea", u"Cantidad", u"Precio", u"Importe"]
        self.ui.taPresupuesto.setColumnCount(len(labels))
        self.ui.taPresupuesto.setHorizontalHeaderLabels(labels)
        self.ui.lyPresupuesto.insertWidget(1, self.ui.taPresupuesto)

        self.ui.taPresupuesto.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)

        self.ui.taVenta = TablaPartidas(self, owner=self)
        self.ui.taVenta.setColumnCount(len(labels))
        self.ui.taVenta.setHorizontalHeaderLabels(labels)
        self.ui.lyVenta.insertWidget(1, self.ui.taVenta)

        self.ui.taVenta.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.toImprimir.setIcon(icon)
        self.connect(self.ui.toImprimir, QtCore.SIGNAL("clicked()"), self.imprimir)

        self.status = 'normal'

        self.impuestoGeneralFactor = (manejador.impuestoGeneral() + dec('100')) / dec('100')

        self.__rangoPrecioActual = 0


    def cargaRangosPrecioActivos(self):
        rangosPrecio = manejador.rangosPrecio()
        self.__rangosPrecioActivos = []
        for index, rango in enumerate(rangosPrecio):
            if u'a' in rango.referencia:
                self.__rangosPrecioActivos.append(rango)


    def imprimir(self):
        documento = ([x for x in self.proceso.operaciones if x.tipo==u'salida'][0]).documentos[0]
        self.owner.imprime(documento)


    @property
    def impuestoIncluido(self):
        return self.__impuestoIncluido


    def mostrar(self, id):
        self.data = manejador.dameUno(id=id)
        self.setData(self.data)
        self.show()


    @property
    def rangosPrecioActivos(self):
        return self.__rangosPrecioActivos


    @property
    def rangoPrecioActual(self):
        return self.__rangoPrecioActual


    def setData(self, data):
        m = "servicios.igu.Detalles.setData()"

        self.proceso = data

        docServicio = [x.documentos[0] for x in data.operaciones if x.tipo==u'recepción'][0]

        cliente = manejador.dameCliente(id=docServicio.rol_id)
        direccion = cliente.direcciones[0]

        docPresupuesto = [x.documentos[0] for x in data.operaciones if x.tipo==u'solicitud']
        if docPresupuesto:
            docPresupuesto = docPresupuesto[0]

        docVenta = [x.documentos[0] for x in data.operaciones if x.tipo==u'salida']
        if docVenta:
            docVenta = docVenta[0]

        self.ui.laFolio.setText("%s" % docServicio.folio)
        self.ui.laFecha.setText(docServicio.fecha.strftime("%d %b %Y"))

        self.ui.laNombreCliente.setText("%s %s" % (cliente.entidad.nombre, cliente.entidad.nombre2))
        domicilio = direccion.calle
        if direccion.areanominal:
            domicilio += ", %s" % direccion.areanominal
        self.ui.laDomicilio.setText("%s" % domicilio)
        if direccion.lugar:
            self.ui.laLugar.setText("%s" % direccion.lugar.nombre)
        self.ui.laRFC.setText("%s" % cliente.entidad.rfc)

        self.ui.laTipoEquipo.setText("%s %s %s" % (docServicio.servicio.equipo.marca.nombre, docServicio.servicio.equipo.linea.nombre, docServicio.servicio.equipo.modelo.nombre))
        if docServicio.servicio.accesorios:
            self.ui.laAccesorios.setText(docServicio.servicio.accesorios)
        self.ui.teSintomas.setText(docServicio.servicio.sintomas)

        if docServicio.servicio.diagnostico:
            self.ui.teDiagnostico.setText(docServicio.servicio.diagnostico)
            self.ui.laFechaDiagnostico.show()
            self.ui.laFechaDiagnostico.setText(docServicio.servicio.fechadiagnostico.strftime("%d %b %Y"))
            self.ui.laTecnico.show()
            self.ui.laTecnico.setText("%s %s" % (docServicio.servicio.tecnico.entidad.nombre, docServicio.servicio.tecnico.entidad.nombre2))
        else:
            self.ui.teDiagnostico.setText("")
            self.ui.laTecnico.hide()
            self.ui.laFechaDiagnostico.hide()

        if docPresupuesto:
            self.setImpuestoIncluido(True)

            self.ui.taPresupuesto.setDatos(docPresupuesto.partidas)

            self.ui.edSubtotalPresupuesto.setText(str(docPresupuesto.subtotal))
            self.ui.edSubtotalPresupuesto.setMinimumWidth(self.ui.taPresupuesto.columnWidth(5))
            self.ui.edSubtotalPresupuesto.setMaximumWidth(self.ui.taPresupuesto.columnWidth(5))
            self.ui.edDescuentoPresupuesto.setText(str(docPresupuesto.descuento))
            self.ui.edDescuentoPresupuesto.setMinimumWidth(self.ui.taPresupuesto.columnWidth(5))
            self.ui.edDescuentoPresupuesto.setMaximumWidth(self.ui.taPresupuesto.columnWidth(5))
            self.ui.edImpuestoPresupuesto.setText(str(docPresupuesto.impuesto))
            self.ui.edImpuestoPresupuesto.setMinimumWidth(self.ui.taPresupuesto.columnWidth(5))
            self.ui.edImpuestoPresupuesto.setMaximumWidth(self.ui.taPresupuesto.columnWidth(5))
            self.ui.edTotalPresupuesto.setText(str(docPresupuesto.total))
            self.ui.edTotalPresupuesto.setMinimumWidth(self.ui.taPresupuesto.columnWidth(5))
            self.ui.edTotalPresupuesto.setMaximumWidth(self.ui.taPresupuesto.columnWidth(5))

        if docVenta:
            if docVenta.tipo.nombre == u'factura':
                self.setImpuestoIncluido(False)
            elif docVenta.tipo.nombre == u'remisión':
                self.setImpuestoIncluido(True)

            self.ui.taVenta.setDatos(docVenta.partidas)

            self.ui.edSubtotalVenta.setText(str(docVenta.subtotal))
            self.ui.edSubtotalVenta.setMinimumWidth(self.ui.taVenta.columnWidth(5))
            self.ui.edSubtotalVenta.setMaximumWidth(self.ui.taVenta.columnWidth(5))
            self.ui.edDescuentoVenta.setText(str(docVenta.descuento))
            self.ui.edDescuentoVenta.setMinimumWidth(self.ui.taVenta.columnWidth(5))
            self.ui.edDescuentoVenta.setMaximumWidth(self.ui.taVenta.columnWidth(5))
            self.ui.edImpuestoVenta.setText(str(docVenta.impuesto))
            self.ui.edImpuestoVenta.setMinimumWidth(self.ui.taVenta.columnWidth(5))
            self.ui.edImpuestoVenta.setMaximumWidth(self.ui.taVenta.columnWidth(5))
            self.ui.edTotalVenta.setText(str(docVenta.total))
            self.ui.edTotalVenta.setMinimumWidth(self.ui.taVenta.columnWidth(5))
            self.ui.edTotalVenta.setMaximumWidth(self.ui.taVenta.columnWidth(5))


    def setImpuestoIncluido(self, value):
        m = "servicios.Detalles.setImpuestoIncluido()"
        if value:
            self.__impuestoIncluido = True
        else:
            self.__impuestoIncluido = False


class ModeloClientes(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []


    def clear(self):
        # self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        # self.endRemoveRows()


    def data(self, index, role=QtCore.Qt.DisplayRole):      # print "servicios.igu.ModeloClientes().data()"
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            # print "DisplayRole"
            return self.__data[index.row()][index.column()]
        elif role == QtCore.Qt.TextAlignmentRole:
            # print "TextAlignmentRole"
            # if index.column() == CANTIDAD:
                # return QtCore.QVariant(int(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter))
            # if index.column() in [PRECIO, IMPORTE]:
                # return QtCore.QVariant(int(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter))
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        elif role == QtCore.Qt.UserRole:
            # print "UserRole"
            return self.__data[index.row()][1]
        else:
            # print role
            return QtCore.QVariant()


    def insertRow(self, row, parent=QtCore.QModelIndex()):  # print "servicios.igu.ModeloClientes.insertRow()"
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u"")])
        return True


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)


    def setData(self, index, valor, role=QtCore.Qt.DisplayRole):
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            # print "QtCore.Qt.DisplayRole"
            self.__data[index.row()][0] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.UserRole:
            # print "QtCore.Qt.UserRole"
            self.__data[index.row()][1] = QtCore.QVariant(valor)
        else:
            print "puaj"
        return True


class Splitter(QtGui.QSplitter):

    def __init__(self, *args):
        self.orientation = args[0]
        QtGui.QSplitter.__init__(self, *args)

    def createHandle(self):
        return Handle(self.orientation, self)



class Handle(QtGui.QSplitterHandle):

    def __init__(self, *args):
        QtGui.QSplitterHandle.__init__(self, *args)

    def mouseDoubleClickEvent(self, event):     # print "Handle.mousePressEvent()"
        self.emit(QtCore.SIGNAL("handlePressed"))


class Diagnostico(QtGui.QFrame):

    @property
    def status(self):
        return self.__status

    def setStatus(self, status):
        old = self.__status
        self.__status = status
        if old != status:
            self.emit(QtCore.SIGNAL('statusChanged()'))


    def __init__(self, *args, **kwds):  # print "servicios.igu.Diagnostico.__init__()"
        if 'owner' in kwds.keys():
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = diagnostico_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.fecha.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha.setMaximumDate(QtCore.QDate().currentDate())

        ## Técnico
        self.connect(self.ui.cbTecnico, QtCore.SIGNAL('currentIndexChanged(int)'), self.tecnicoSeleccionado)

        # completer = QtGui.QCompleter([], self.ui.edTecnico)
        # completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        # self.ui.edTecnico.setCompleter(completer)
        # self.ui.edTecnico.setStyleSheet("color:#0000FF; background-color:#FFFFFF")
        # self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.tecnicoSeleccionado)
        # self.connect(self.ui.edTecnico, QtCore.SIGNAL('downArrowPressed()'), self.muestraTecnicos)

        ## Diagnóstico
        self.connect(self.ui.teDiagnostico, QtCore.SIGNAL('textChanged()'), self.actualizaStatus)

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.toImprimeDiagnostico.setIcon(icon)
        self.ui.toImprimeDiagnostico.setToolTip(u"No se ha implementado")

        self.connect(self.parent(), QtCore.SIGNAL("empleadosChangedBroadcast()"), self.cargaTecnicos)

        self.tecnico = None

        self.mensajes = u""
        self.mensajesOld = u""
        self.mensajes2 = u""
        self.mensajes2Old = u""

        self.cargaTecnicos()

        self.old = None


    def broadcast(self):
        if self.mensajesOld != self.mensajes:
            self.mensajesOld = self.mensajes
            self.emit(QtCore.SIGNAL('statusChanged()'))


    def actualizaStatus(self):
        if self.owner.modo == "modificar":
            self.esValida()
            self.estaModificado()

        elif self.owner.modo == 'agregar':
            self.esValida()
            self.estaModificado()

        if self.mensajesOld != self.mensajes or self.mensajes2Old != self.mensajes2:
            self.emit(QtCore.SIGNAL('statusChanged()'))


    def cargaTecnicos(self):
        m = "servicios.igu.Diagnostico.cargaTecnicos()"

        self.ui.cbTecnico.clear()

        roles = manejador.dameTecnicos()

        if roles:
            for tecnico in roles:
                self.ui.cbTecnico.addItem("%s %s" % (tecnico.entidad.nombre, tecnico.entidad.nombre2), QtCore.QVariant(tecnico.id))
            self.ui.cbTecnico.setCurrentIndex(-1)
        else:
            self.ui.cbTecnico.addItem(u"No hay técnicos registrados", -1)


    def clear(self):
        self.ui.teDiagnostico.clear()
        self.ui.cbTecnico.setCurrentIndex(-1)


    def datos(self):
        datos = {}
        datos['fecha'] = self.ui.fecha.dateTime().toPyDateTime()
        if self.ui.cbTecnico.currentIndex() >= 0:
            datos['tecnico_id'] = self.ui.cbTecnico.itemData(self.ui.cbTecnico.currentIndex()).toInt()[0]
        else:
            datos['tecnico_id'] = None
        datos['diagnostico'] = unicode(self.ui.teDiagnostico.document().toPlainText())
        return datos


    def estaModificado(self):
        modificado = False

        self.mensajes2Old = self.mensajes2
        self.mensajes2 = u""

        datos = self.datos()

        if self.old:
            if self.old.fechadiagnostico != datos['fecha']:
                self.mensajes2 += u"  Fecha modificada\n"
                modificado = True

            if self.old.tecnico:
                if self.old.tecnico.id != datos['tecnico_id']:
                    self.mensajes2 += u"  Técnico cambiado\n"
                    modificado = True
            else:
                if datos['tecnico_id']:
                    self.mensajes2 += u"  Técnico cambiado\n"
                    modificado = True

            if self.old.diagnostico != datos['diagnostico']:
                self.mensajes2 += u"  Diagnóstico modificado\n"
                modificado = True

        self.mensajes2.rstrip('\n')

        return modificado


    def esValida(self):
        valida = True

        self.mensajesOld = self.mensajes
        self.mensajes = u""

        if self.ui.cbTecnico.currentIndex() < 0:
            valida = False
            self.mensajes += u"  Falta seleccionar el técnico\n"

        ## Fecha es igual o mayor que fecha de recepción ?
        # if self.ui.fecha.dataTime().toPyDateTime()

        if not self.ui.teDiagnostico.document().toPlainText():
            valida = False
            self.mensajes += u"  No ha capturado el diagnóstico\n"

        if u'técnico' in self.mensajes and u'diagnóstico' in self.mensajes:
            valida = True

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    def muestraTecnicos(self):
        self.ui.edTecnico.completer().setCompletionPrefix(self.ui.edTecnico.text())
        self.ui.edTecnico.completer().complete()


    @property
    def owner(self):
        return self.__owner


    def setDatos(self, datos):
        self.old = datos
        if datos.fechadiagnostico:
            self.ui.fecha.setDate(QtCore.QDate().fromString(datos.fechadiagnostico.strftime("%d%m%Y"), "ddMMyyyy"))
        if datos.tecnico:
            self.ui.cbTecnico.setCurrentIndex(self.ui.cbTecnico.findData(QtCore.QVariant(datos.tecnico.id)))
        self.tecnico = datos.tecnico
        if datos.diagnostico:
            self.ui.teDiagnostico.setText(datos.diagnostico)


    # def tecnicoGotFocus(self):
        # self.ui.edTecnico.completer().complete()


    def tecnicoSeleccionado(self, index):   #
        self.actualizaStatus()



class Modelo(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []


    def clear(self):
        self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.endRemoveRows()


    def data(self, index, role=QtCore.Qt.DisplayRole):  # print "clientes.selectorCliente.ModeloNombre.data()"

        if role in [QtCore.Qt.DisplayRole]:
            # print "data.DisplayRole"
            return self.__data[index.row()][index.column()]
        elif role in [QtCore.Qt.EditRole]:
            # print "data.EditRole"
            return self.__data[index.row()][1]
        elif role == QtCore.Qt.TextAlignmentRole:
            # print "TextAlignmentRole"
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        elif role == QtCore.Qt.UserRole:
            # print "data.UserRole"
            return self.__data[index.row()][2]
        else:
            # print role
            return QtCore.QVariant()


    def insertRow(self, row, parent=QtCore.QModelIndex()):  # print "equipos.igu.ModeloClientes.insertRow()"
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u""), QtCore.QVariant(u"")])
        return True


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)


    def reload(self):
        pass


    def setData(self, index, valor, role=QtCore.Qt.DisplayRole):
        if role == QtCore.Qt.DisplayRole:       # Zero
        # if role & QtCore.Qt.DisplayRole:
            # print "setData.DisplayRole"
            self.__data[index.row()][0] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.EditRole:
            # print "setData.EditRole"
            self.__data[index.row()][1] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.UserRole:
            # print "setData.UserRole"
            self.__data[index.row()][2] = valor
        else:
            print 12345, role
        return True



class Pago(QtGui.QDialog):

    def __init__(self, *args, **kwds):
        QtGui.QDialog.__init__(self, *args)

        self.ui = pagos_ui.Ui_Dialog()
        self.ui.setupUi(self)

        self.setWindowTitle(QtGui.QApplication.translate("DsDialog", "Taller Básico", None, QtGui.QApplication.UnicodeUTF8))
        self.setWindowIcon(QtGui.QIcon("imagenes/logo.png"))

        # icon = QtGui.QIcon()
        # icon.addPixmap(QtGui.QPixmap("imagenes/Cash.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        # self.aEfectivo = QtGui.QAction(icon, u"&Efectivo", self)
        # self.aEfectivo.setCheckable(True)
        # self.aEfectivo.setIconText(u"&Efectivo")
        # self.ui.toEfectivo.setDefaultAction(self.aEfectivo)
        # self.connect(self.aEfectivo, QtCore.SIGNAL('triggered()'), self.triggered)

        # icon = QtGui.QIcon()
        # icon.addPixmap(QtGui.QPixmap("imagenes/Edit.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        # self.aCheque = QtGui.QAction(icon, u"&Cheque", self)
        # self.aCheque.setCheckable(True)
        # self.aCheque.setIconText(u"&Cheque")
        # self.ui.toCheque.setDefaultAction(self.aCheque)
        # self.connect(self.aCheque, QtCore.SIGNAL('triggered()'), self.triggered)

        # icon = QtGui.QIcon()
        # icon.addPixmap(QtGui.QPixmap("imagenes/Folder.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        # self.aCredito = QtGui.QAction(icon, u"&Credito", self)
        # self.aCredito.setCheckable(True)
        # self.aCredito.setIconText(u"&Credito")
        # self.ui.toCredito.setDefaultAction(self.aCredito)
        # self.connect(self.aCredito, QtCore.SIGNAL('triggered()'), self.triggered)

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boToggle.setIcon(icon)
        self.connect(self.ui.boToggle, QtCore.SIGNAL('clicked()'), self.triggered)

        # self.ui.toCheque.hide()
        # self.ui.toCredito.hide()
        # self.ui.toTarjeta.hide()

        self.tipos = [x.nombre for x in manejador.formasPagoI()]

        ## Importe
        self.ui.edImporte.setEnabled(False)

        ## Efectivo - recibido
        self.ui.edMontoRecibido.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edMontoRecibido.setStyleSheet('background-color:#F8F8FF;')
        self.ui.edMontoRecibido.setRange(0, 99999)
        self.ui.edMontoRecibido.setPrefijoMensaje("el pago")
        self.connect(self.ui.edMontoRecibido, QtCore.SIGNAL("textEdited(QString)"), self.actualizaCambio)

        ## Efectivo - cambio
        self.ui.edCambio.setEnabled(False)

        ## Credito - plazo
        self.cargaCondiciones()
        self.connect(self.ui.cbPlazo, QtCore.SIGNAL('activated(int)'), self.plazoSeleccionado)

        ## Credito - pago inicial
        self.ui.frPagoInicial.hide()

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.connect(self.ui.boCancelar, QtCore.SIGNAL('clicked()'), self.cancelar)

        ## Aceptar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Checkmark.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boAceptar.setIcon(icon)
        self.connect(self.ui.boAceptar, QtCore.SIGNAL('clicked()'), self.aceptar)

        self.__tipo = 0
        self.triggered(0)
        self.__capturado = False


    def aceptar(self):
        self.__capturado = True
        self.accept()


    def actualizaCambio(self):  # print "servicios.igu.Pago.actualizaCambio()"
        cambio = self.ui.edMontoRecibido.value() - self.ui.edImporte.value()
        self.ui.edCambio.setValue(cambio)
        self.actualizaStatus()


    def actualizaStatus(self):
        if self.esValido():
            self.ui.boAceptar.setEnabled(True)
            self.ui.boAceptar.setToolTip(u'OK')
        else:
            self.ui.boAceptar.setEnabled(False)
            self.ui.boAceptar.setToolTip(self.mensajes)


    def cancelar(self):
        self.reject()


    @property
    def capturado(self):
        return self.__capturado


    def cargaCondiciones(self): # print "servicios.igu.Pago.cargaCondiciones()"
        registros = manejador.condicionesPago()
        self.ui.cbPlazo.clear()
        for registro in registros:
            self.ui.cbPlazo.addItem(registro.valor, QtCore.QVariant(registro.id))

    def clear(self):
        self.__capturado = False
        self.__tipo = 0

        self.ui.edImporte.setText(u'')
        self.ui.edMontoRecibido.setText(u'')
        self.ui.edCambio.setText(u'')

        self.ui.cbPlazo.setCurrentIndex(-1)


    def datos(self):
        datos = {}
        datos['total'] = self.ui.edImporte.value()
        if self.tipos[self.tipo] == u'efectivo':
            datos['tipo'] = u'efectivo'
            datos['recibido'] = self.ui.edMontoRecibido.value()
            datos['cambio'] = self.ui.edCambio.value()
        elif self.tipos['self.tipo'] == u'cheque':
            datos['tipo'] = u'cheque'
            datos['fecha'] = self.ui.daFecha.dateTime.toPyDate()
            datos['numero'] = self.ui.edNumero.text()
            datos['banco_id'] = self.ui.cbBanco.itemData(self.ui.cbBanco.currentIndex())
            # datos['emisor_id'] = self.
            datos['monto'] = self.ui.edMonto.value()

        return datos


    def esValido(self):         # print "servicios.igu.Pago.esValido()"
        valido = True
        self.mensajes = u''
        if self.tipos[self.tipo] == u'Efectivo':
            if self.ui.edCambio.value() < dec('0'):
                valido = False
                self.mensajes += u"El monto recibido no es válido\n"
        elif self.tipos[self.tipo] == u'Crédito':
            if not self.ui.cbPlazo.currentText():
                valido = False
                self.mensajes += u"Falta el plazo\n"

        elif self.tipos[self.tipo] == u'Banco':
            if not self.ui.cbBanco.currentText():
                valido = False
                self.mensajes += u"Falta el Banco\n"
        self.mensajes = self.mensajes.rstrip('\n')
        return valido


    def setDatos(self, datos):
        self.ui.edImporte.setValue(datos.total)

        if datos.tipo.nombre == u'efectivo':
            self.ui.edMontoRecibido.setValue(datos.subtotal)
            self.ui.edCambio.setValue(datos.descuento)
        elif datos.tipo.nombre == u'banco':
            self.ui.cbBanco.setEditText(referencia[1])
            self.ui.edNumero.setText(referencia[1])
            self.ui.daFecha.setDate(referencia[1])
            self.ui.edMonto.setValue(dec(referencia[1]))
            self.ui.edEmisor.setText(referencia[1])
        elif datos.tipo.nombre == u'crédito':
            self.ui.cbPlazo.setEditText(referencia[1])


    def setFecha(self, fecha):
        self.ui.daFecha.setDate(fecha)


    def setImporte(self, valor):
        self.ui.edImporte.setValue(valor)
        self.actualizaCambio()
        self.ui.edMontoRecibido.setFocus()

    def plazoSeleccionado(self):
        self.actualizaStatus()

    @property
    def tipo(self):
        return self.__tipo

    def triggered(self, index=None): # print "servicios.igu.Pago.triggered()"
        if index is None:
            if self.tipo+1 == len(self.tipos):
                self.__tipo = 0
            else:
                self.__tipo += 1
        else:
            self.__tipo = index

        if self.tipos[self.tipo] == u'cheque':
            self.ui.frEfectivo1.hide()
            self.ui.frCheque1.show()
            self.ui.frCredito1.hide()

            self.ui.frEfectivo.hide()
            self.ui.frBanco.show()
            self.ui.frCredito.hide()

        elif self.tipos[self.tipo] == u'crédito':
            self.ui.frEfectivo1.hide()
            self.ui.frCheque1.hide()
            self.ui.frCredito1.show()

            self.ui.frEfectivo.hide()
            self.ui.frBanco.hide()
            self.ui.frCredito.show()

        elif self.tipos[self.tipo] == u'efectivo':
            self.ui.frEfectivo1.show()
            self.ui.frCheque1.hide()
            self.ui.frCredito1.hide()

            self.ui.frEfectivo.show()
            self.ui.frBanco.hide()
            self.ui.frCredito.hide()
        self.actualizaStatus()



class Presupuesto(QtGui.QFrame):

    @property
    def modo(self):
        return self.__owner.modo

    @property
    def status(self):
        return self.__status

    def setStatus(self, status):
        old = self.__status
        self.__status = status
        if old != status:
            self.emit(QtCore.SIGNAL('statusChanged()'))


    def __init__(self, *args, **kwds):
        if 'owner' in kwds.keys():
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = presupuesto_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.fecha.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha.setMaximumDate(QtCore.QDate().currentDate())

        ## Nombre de producto
        self.ui.label_2.setText(QtGui.QApplication.translate("Form", "&Nombre de artículo", None, QtGui.QApplication.UnicodeUTF8))
        completer = QtGui.QCompleter([], self.ui.edNombreProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.ui.edNombreProducto.setCompleter(completer)
        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.nombreProductoSeleccionado)
        self.connect(self.ui.edNombreProducto, QtCore.SIGNAL("textEdited(QString)"), self.nombreProductoEditado)

        ## Línea de producto
        completer = QtGui.QCompleter([], self.ui.edLineaProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.ui.edLineaProducto.setCompleter(completer)
        self.connect(self.ui.edLineaProducto, QtCore.SIGNAL("textEdited(QString)"), self.lineaProductoEditada)

        ##     Tabla Partidas Presupuesto
        self.ui.tablaPartidas = TablaPartidas(self, owner=self)
        # self.ui.tablaPartidasPresupuesto.setStyleSheet('background-color:#F8F8FF')
        labels = [u"Código", u"Nombre", u"Línea", u"Cantidad", u"Precio", u"Importe"]
        self.ui.tablaPartidas.setColumnCount(len(labels))
        self.ui.tablaPartidas.setHorizontalHeaderLabels(labels)
        self.ui.tablaPartidas.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)
        self.ui.layoutCaptura.insertWidget(2, self.ui.tablaPartidas)
        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL("totalChanged(dec)"), self.totalChanged)

        self.ui.edSubtotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edSubtotal.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edSubtotal.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))

        self.ui.edDescuento.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edDescuento.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edDescuento.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))

        self.ui.edImpuesto.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edImpuesto.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edImpuesto.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))

        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(9)
        self.ui.edTotal.setFont(font)
        self.ui.edTotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edTotal.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edTotal.setMinimumWidth(self.ui.tablaPartidas.columnWidth(5))

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.toImprimePresupuesto.setIcon(icon)
        self.ui.toImprimePresupuesto.setToolTip(u"No se ha implementado")

        self.ui.edNombreProducto.setFocus()

        self.mensajes = u""
        self.mensajes2 = u""
        # self.old = manejador.Documento(**self.datos())
        self.old = None
        self.__status = 'not valid'

        ## Rangos Precio
        self.toggleRangoPrecio(0)

        self.impuestoGeneralFactor = (manejador.impuestoGeneral() + dec('100')) / dec('100')
        self.setImpuestoIncluido(True)


    def actualizaStatus(self):      # print "servicios.igu.Presupuesto.actualizaStatus()"
        if self.owner.modo == "modificar":
            self.esValida()
            self.broadcast()
            # if self.estaModificado():
                # if self.esValida():
                    # self.ui.boGuardar.setEnabled(True)
                    # self.ui.boGuardar.setToolTip(u"")
                # else:
                    # self.ui.boGuardar.setEnabled(False)
                    # self.ui.boGuardar.setToolTip(u"No hay cambios")
            # else:
                # self.ui.boGuardar.setEnabled(False)
                # self.ui.boGuardar.setToolTip(u"No hay cambios")
        elif self.owner.modo == 'agregar':
            if self.esValida():
                self.setStatus('valid')
            else:
                self.setStatus('not valid')
            # if self.esValida():
                # if not self.lastState:
                    # self.lastState = True
                    # self.emit(QtCore.SIGNAL("presupuestoChanged(bool)"), True)
            # else:
                # if self.lastState:
                    # self.lastState = False
                    # self.emit(QtCore.SIGNAL("presupuestoChanged(bool)"), False)


    def broadcast(self):
        # if self.mensajesOld != self.mensajes:
        self.emit(QtCore.SIGNAL('statusChanged()'))


    def clear(self):
        self.ui.edFolio.setText(manejador.dameFolioPresupuesto())
        self.ui.edCodigoProducto.clear()
        self.ui.edNombreProducto.clear()
        self.ui.edLineaProducto.clear()
        self.ui.tablaPartidas.clear()
        self.ui.edSubtotal.clear()
        self.ui.edDescuento.clear()
        self.ui.edImpuesto.clear()
        self.ui.edTotal.clear()
        self.ui.laCantidadConLetra.clear()


    def datos(self):                # print "servicios.igu.Presupuesto.datos()"
        datos = {}
        datos['folio'] = unicode(self.ui.edFolio.text())
        datos['fecha'] = self.ui.fecha.dateTime().toPyDateTime()
        datos['subtotal'] = self.ui.edSubtotal.value()
        datos['descuento'] = self.ui.edDescuento.value()
        # datos['descuentoporcentaje'] = self.ui.edDescuentoPorcentaje.value()
        datos['impuesto'] = self.ui.edImpuesto.value()
        # datos['impuestoporcentaje'] = self.ui.edImpuestoPorcentaje.value()
        datos['total'] = self.ui.edTotal.value()
        # datos['status'] = u'Activo'
        datos['partidas'] = self.ui.tablaPartidas.data()
        return datos


    def estaModificado(self):
        modificado = False
        self.mensajes2 = u""

        if self.owner.modo == 'modificar':
            data = self.datos()
            # try:
            # print type(self.old)
            # if type(self.old)==dict:
            if self.old:
                if type(self.old) == dict:

                    if self.old['folio'] != data['folio']:
                        modificado = True
                        self.mensajes2 += "   Folio modificado\n"

                    if self.old['fecha'] != data['fecha']:
                        modificado = True
                        self.mensajes2 += "   Fecha modificada\n"

                    # if self.old['subtotal'] != data['subtotal']:
                        # modificado = True
                        # self.mensajes2 += "Subtotal modificado\n"

                    # if self.old['descuento'] != data['descuento']:
                        # modificado = True
                        # self.mensajes2 += "Descuento modificado\n"

                    # if self.old['impuesto'] != data['impuesto']:
                        # modificado = True
                        # self.mensajes2 += "Impuesto modificado\n"

                    # if self.old['total'] != data['total']:
                        # modificado = True
                        # self.mensajes2 += "Total modificado\n"

                    if self.ui.tablaPartidas.estaModificado():
                        modificado = True
                        self.mensajes2 += "   Partidas modificadas\n"

                else:
                    if self.old.folio != data['folio']:
                        modificado = True
                        self.mensajes2 += "   Folio modificado\n"

                    if self.old.fecha != data['fecha']:
                        modificado = True
                        self.mensajes2 += "   Fecha modificada\n"

                    # if self.old.subtotal != data['subtotal']:
                        # modificado = True
                        # self.mensajes2 += "Subtotal modificado\n"

                    # if self.old.descuento != data['descuento']:
                        # modificado = True
                        # self.mensajes2 += "Descuento modificado\n"

                    # if self.old.impuesto != data['impuesto']:
                        # modificado = True
                        # self.mensajes2 += "Impuesto modificado\n"

                    # if self.old.total != data['total']:
                        # modificado = True
                        # self.mensajes2 += "Total modificado\n"

                    if self.ui.tablaPartidas.estaModificado():
                        modificado = True
                        self.mensajes2 += "   Partidas modificadas\n"

            else:
                if 0==data['subtotal']:
                    if 0==data['descuento']:
                        if 0==data['impuesto']:
                            if 0==data['total']:
                                if not self.ui.tablaPartidas.estaModificado():
                                    modificado = False
                modificado = True
        else:
            modificado = True

        # if modificado:
            # print self.mensajes2
            # print self.old
            # print data

            # print type(self.old.fecha), type(data['fecha'])


        return modificado


    def esValida(self):
        valida = True

        self.mensajesOld = self.mensajes
        self.mensajes = u""

        ## Fecha es igual o mayor que fecha de recepción ?

        if not self.ui.fecha.lineEdit().text():
            valida = False
            self.mensajes += u"Falta la fecha\n"

        partidasValida = self.ui.tablaPartidas.esValida()
        if not partidasValida:
            if u'sin cantidad' in self.ui.tablaPartidas.mensajes:
                valida = False

        mensajesPartidas = "".join([x for x in self.ui.tablaPartidas.mensajes.split('\n') if u'existencia' not in x])

        self.mensajes += mensajesPartidas + '\n'

        if not self.ui.edTotal.isValid:
            valida = False
            self.mensajes += u"Total fuera de rango\n"

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    @property
    def impuestoIncluido(self):
        return self.__impuestoIncluido


    def lineaProductoEditada(self, texto): # print "servicios.Presupuesto.lineaProductoEditada()"
        filtros = {}
        filtros['nombre'] = unicode(texto)

        lineas = manejador.dameLineas(**filtros)

        ids = [x.id for x in lineas]
        nombres = ["%s" % x.valor for x in lineas]

        self.sender().completer().data = ids
        self.sender().completer().model().setStringList(nombres)


    def nombreProductoEditado(self, texto):
        if len(texto) < 2:
            acepciones = []
            self.sender().completer().data = []
            self.sender().completer().model().setStringList([])
        elif len(texto) == 2:
            filtros = {}
            filtros['nombre'] = unicode(texto)
            filtros['rol_id'] = self.owner.owner.app.holder.id

            # if self.ui.edClasificacion.text():
                # filtros['linea'] = unicode(self.ui.edClasificacion.text())

            if self.ui.edLineaProducto.text():
                filtros['linea'] = self.ui.edLineaProducto.text()

            acepciones = manejador.dameAcepciones(**filtros)

            ids = [x.id for x in acepciones]
            nombres = ["%s %s %s" % (x.nombre, x.producto.lineas[0].nombre, x.codigo) for x in acepciones]

            self.sender().completer().data = ids
            self.sender().completer().model().setStringList(nombres)

            self.actualizaStatus()


    def nombreProductoSeleccionado(self, completerModelIndex):
        m = "servicios.Presupuesto.nombreProductoSeleccionado()"

        acepcion = manejador.dameAcepcion(id=self.sender().data[completerModelIndex.row()])
        # producto = acepcion.producto

        # row = self.ui.tablaPartidas.rowCount()
        # self.ui.tablaPartidas.insertRow(row)

        # precioLista = [x for x in producto.atributos if x.nombre==u'precio' and x.atributo_id==self.rangosPrecioActivos[self.rangoPrecioActual].id]

        # if precioLista:
            # precio = dec(precioLista[0].valor)
        # else:
            # precio = dec("0.00")

        precio = "dummy"

        ## row, acepcion, cantidad, precio
        row = self.ui.tablaPartidas.setDatosRenglon(None, acepcion, dec('0'), None)

        self.ui.edCodigoProducto.setText("")
        self.ui.edNombreProducto.setText("")
        # self.ui.cbClasificacion.setCurrentIndex(0)

        self.ui.tablaPartidas.setCurrentCell(row, CANTIDAD)
        self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(row, CANTIDAD))

        self.actualizaStatus()


    @property
    def owner(self):
        return self.__owner


    @property
    def rangoPrecioActual(self):
        ## Index
        return self.__rangoPrecioActual


    @property
    def rangosPrecioActivos(self):
        return self.owner.rangosPrecioActivos


    def setDatos(self, datos):
        self.ui.edFolio.setText(datos.folio)
        self.ui.fecha.setDate(QtCore.QDate().fromString(datos.fecha.strftime("%d%m%Y"), "ddMMyyyy"))
        self.ui.edSubtotal.setValue(datos.subtotal)
        self.ui.edDescuento.setValue(datos.descuento)
        self.ui.edImpuesto.setValue(datos.impuesto)
        self.ui.edTotal.setValue(datos.total)

        self.ui.tablaPartidas.setDatos(datos.partidas)


    def setImpuestoIncluido(self, value):
        m = "servicios.Presupuesto.setImpuestoIncluido()"

        if value:
            self.__impuestoIncluido = True
        else:
            self.__impuestoIncluido = False

        self.emit(QtCore.SIGNAL("totalChanged(dec)"), self.ui.tablaPartidas.getSubtotal())


    def setOld(self, datos):
        self.old = datos
        if type(self.old) == dict:
            self.ui.tablaPartidas.setOld(datos['partidas'])
        else:
            self.ui.tablaPartidas.setOld(datos.partidas)


    def toggleRangoPrecio(self, rango=None):
        if rango is None:   # rango es el index
            if self.rangoPrecioActual+1 == len(self.rangosPrecioActivos):
                self.__rangoPrecioActual = 0
            else:
                self.__rangoPrecioActual += 1
        else:
            self.__rangoPrecioActual = rango

        self.ui.tablaPartidas.cambiaPrecios(self.rangoPrecioActual)


    def totalChanged(self, subtotal): # print "servicios.Presupuesto.totalChanged()"
        descuento = subtotal * dec('0.00')
        impuesto = dec('0.00')
        total = subtotal + impuesto
        self.ui.edSubtotal.setText("%.2f" % subtotal)
        self.ui.edDescuento.setText("%.2f" % descuento)
        self.ui.edImpuesto.setText("%.2f" % impuesto)
        self.ui.edTotal.setText("%.2f" % total)
        # if total:
            # self.ui.laTotalConLetras.setText("Son %s" % utilities.moneyToText(dec(str(total))))
        # self.actualizaStatus()
        self.emit(QtCore.SIGNAL('edited()'))



class Recepcion(QtGui.QFrame):

    def __init__(self, *args, **kwds):
        if 'owner' in kwds.keys():
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = recepcion_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.fecha.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha.setMaximumDate(QtCore.QDate().currentDate())

        ## Cliente
        self.ui.selectorCliente = selectorCliente.Forma(self, u'clientes')
        self.ui.frCliente.setStyleSheet("QFrame{background-color:qradialgradient(cx:.5, cy:.5, radius:1,fx:.5, fy:.25, stop: 0 #FFFFFF, stop:1 #B0B0B0); border-radius: 3px;}")

        # self.ui.selectorCliente.setContent(self.ui.selectorCliente.content() ^ self.ui.selectorCliente.RFC)
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL("clienteSelected()"), self.clienteSeleccionado)
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL("clienteEdited()"), self.clienteEditado)
        self.ui.lyCliente.insertWidget(1, self.ui.selectorCliente)

        self.ui.selectorCliente.setRfcObligatorio(False)

        self.propietario = None

        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(8*self.owner.app.fontZoom)

        ## Equipo
        # horizontalHeaderLabels = [u"Económico", u"Placa"]
        # self.ui.taConsulta.setColumnCount(len(horizontalHeaderLabels))
        # self.ui.taConsulta.setHorizontalHeaderLabels(horizontalHeaderLabels)
        self.ui.taConsulta.hide()

        ##      Codigo
        self.ui.cbCodigo.lineEdit().setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
        self.ui.cbCodigo.lineEdit().setStyleSheet('color:#0000FF; background-color:#FFFFFF;')
        self.ui.cbCodigo.lineEdit().setFont(font)
        self.connect(self.ui.cbCodigo, QtCore.SIGNAL('activated(int)'), self.codigoSeleccionado)

        ##      Registro
        self.ui.cbRegistro.lineEdit().setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
        self.ui.cbRegistro.lineEdit().setStyleSheet('color:#0000FF; background-color:#FFFFFF;')
        self.ui.cbRegistro.lineEdit().setFont(font)
        self.connect(self.ui.cbRegistro, QtCore.SIGNAL('editTextChanged(QString)'), self.registroEditado)
        self.connect(self.ui.cbRegistro, QtCore.SIGNAL('activated(int)'), self.registroSeleccionado)

        ##      Marca
        self.ui.cbMarca.lineEdit().setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
        self.ui.cbMarca.lineEdit().setStyleSheet('color:#0000FF; background-color:#FFFFFF;')
        self.ui.cbMarca.lineEdit().setFont(font)
        self.connect(self.ui.cbMarca, QtCore.SIGNAL('activated(int)'), self.marcaSeleccionada)
        self.cargaMarcas()

        ##      Línea
        self.ui.cbLinea.lineEdit().setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
        self.ui.cbLinea.lineEdit().setStyleSheet('color:#0000FF; background-color:#FFFFFF;')
        self.ui.cbLinea.lineEdit().setFont(font)

        ##      Modelo
        self.ui.cbModelo.lineEdit().setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
        self.ui.cbModelo.lineEdit().setStyleSheet('color:#0000FF; background-color:#FFFFFF;')
        self.ui.cbModelo.lineEdit().setFont(font)

        ##      Características
        self.ui.edCaracteristicas.setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)

        self.cargaEquipos()
        self.equipo = None

        ## Nivel1
        self.connect(self.ui.edNivel1, QtCore.SIGNAL('editingFinished()'), self.nivel1Capturado)

        ## Nivel2
        self.connect(self.ui.edNivel2, QtCore.SIGNAL('editingFinished()'), self.nivel2Capturado)

        ##     Síntomas
        self.connect(self.ui.teSintomas, QtCore.SIGNAL('textChanged()'), self.sintomasEdited)

        self.setTabOrder(self.ui.fecha, self.ui.selectorCliente)
        # self.setTabOrder(self.ui.selectorCliente.ui.edTelefono, self.ui.edTipo)
        # self.setTabOrder(self.ui.edTipo, self.ui.edMarca)
        self.setTabOrder(self.ui.selectorCliente, self.ui.cbCodigo)
        self.setTabOrder(self.ui.cbCodigo, self.ui.edSerie)
        self.setTabOrder(self.ui.edSerie, self.ui.cbRegistro)
        self.setTabOrder(self.ui.cbRegistro, self.ui.cbMarca)
        self.setTabOrder(self.ui.cbMarca, self.ui.cbLinea)
        self.setTabOrder(self.ui.cbLinea, self.ui.cbModelo)
        self.setTabOrder(self.ui.cbModelo, self.ui.edCaracteristicas)
        self.setTabOrder(self.ui.edCaracteristicas, self.ui.teAccesorios)
        self.setTabOrder(self.ui.teAccesorios, self.ui.edNivel1)
        self.setTabOrder(self.ui.edNivel1, self.ui.edNivel2)
        self.setTabOrder(self.ui.edNivel2, self.ui.teSintomas)

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.toImprimeRecepcion.setIcon(icon)
        self.ui.toImprimeRecepcion.setToolTip(u"No se ha implementado")

        # self.__status = 'not valid'
        self.mensajes = u""
        self.mensajes2 = u""
        self.mensajes2Old = u""


    def broadcast(self):
        if self.mensajesOld != self.mensajes or self.mensajes2Old != self.mensajes2:
            self.emit(QtCore.SIGNAL('statusChanged()'))


    def actualizaStatus(self):              # print "servicios.Recepcion.actualizaStatus()"
        if self.owner.modo == 'modificar':
            self.esValida()
            self.estaModificado()
            self.broadcast()
            # if self.estaModificado():
                # if self.esValida():
                    # self.ui.boGuardar.setEnabled(True)
                    # self.ui.boGuardar.setToolTip(u"")
                # else:
                    # self.ui.boGuardar.setEnabled(False)
                    # self.ui.boGuardar.setToolTip(u"No hay cambios")
            # else:
                # self.ui.boGuardar.setEnabled(False)
                # self.ui.boGuardar.setToolTip(u"No hay cambios")
        elif self.owner.modo == 'agregar':
            self.esValida()
            self.broadcast()
            # if self.esValida():
                # self.setStatus('valid')
            # else:
                # self.setStatus('not valid')


    def cargaEquipos(self, propietario_id=None): # print "servicios.Recepcion.cargaEquipos()"
        if propietario_id:
            self.ui.cbCodigo.clear()
            self.ui.cbRegistro.clear()

            registros = manejador.dameEquipos(propietario=propietario_id)

            for rowIndex, registro in enumerate(registros):
                self.ui.taConsulta.insertRow(rowIndex)
                item = QtGui.QTableWidgetItem(registro.codigo)
                self.ui.taConsulta.setItem(rowIndex, 0, item)

                self.ui.cbCodigo.addItem(registro.codigo, registro.id)
                self.ui.cbRegistro.addItem(registro.registro, registro.id)

            self.ui.cbCodigo.setCurrentIndex(-1)
            self.ui.cbRegistro.setCurrentIndex(-1)

        else:
            registros = []


    def cargaLineas(self, marca=None):
        self.ui.cbLinea.clear()
        filtros = {}
        if marca:
            filtros['marca'] = marca
        lineas = manejador.dameLineas(**filtros)
        for linea in lineas:
            self.ui.cbLinea.addItem(linea.nombre, linea.id)


    def cargaCodigos(self, propietario_id=None):
        if propietario_id:
            equipos = manejador.dameEquipos(propietario_id=propietario_id)
        else:
            equipos = manejador.dameEquipos()


    def cargaMarcas(self):
        self.ui.cbMarca.clear()
        marcas = manejador.dameMarcas()
        for marca in marcas:
            # item = QtGui.QListWidgetItem(marca.nombre)
            # item.setData(1000, marca.code)
            self.ui.cbMarca.addItem(marca.nombre, marca.id)


    def cargaModelos(self, linea=None):
        self.ui.cbModelo.clear()
        filtros = {}
        if linea:
            filtros['linea'] = linea
        modelos = manejador.dameModelos(**filtros)
        for modelo in modelos:
            self.ui.cbModelo.addItem(modelo.nombre, modelo.id)


    def cargaTipos(self):
        self.ui.liTipo.clear()
        tipos = manejador.dameTipos()
        for tipo in tipos:
            item = QtGui.QListWidgetItem(tipo.nombre)
            item.setData(1000, tipo.code)
            self.ui.liTipo.addItem(item)


    def clear(self):
        self.ui.selectorCliente.clear()
        self.equipo = None
        # self.ui.edNombre.clear()
        # self.ui.edTipo.clear()
        self.ui.cbCodigo.setCurrentIndex(-1)
        self.ui.edSerie.clear()
        self.ui.cbRegistro.setCurrentIndex(-1)
        self.ui.cbMarca.setCurrentIndex(-1)
        self.ui.cbLinea.setCurrentIndex(-1)
        self.ui.cbModelo.setCurrentIndex(-1)
        self.ui.edCaracteristicas.clear()
        self.ui.teAccesorios.clear()
        self.ui.edNivel1.clear()
        self.ui.edNivel2.clear()
        self.ui.teSintomas.clear()


    def clienteEditado(self):
        self.owner.actualizaStatus()


    def clienteSeleccionado(self):
        self.owner.actualizaStatus()
        self.cargaEquipos(self.ui.selectorCliente.rol.id)
        # self.emit(QtCore.SIGNAL('clienteSeleccionado()'))


    def codigoSeleccionado(self, index):
        equipo = manejador.dameEquipo(id=self.ui.cbCodigo.itemData(index).toInt()[0])
        self.setDatosEquipo(equipo)
        self.owner.actualizaStatus()


    def registroSeleccionado(self, index):
        equipo = manejador.dameEquipo(id=self.ui.cbRegistro.itemData(index).toInt()[0])
        self.setDatosEquipo(equipo)


    def datos(self):
        datos = {}
        if self.owner.proceso:
            datos['proceso'] = self.owner.proceso

        datos['fecha'] = self.ui.fecha.dateTime().toPyDateTime()

        if self.ui.selectorCliente.rol:
            datos['cliente'] = self.ui.selectorCliente.rol
        else:
            datos['cliente'] = self.ui.selectorCliente.data()


        if self.equipo:
            datos['equipo'] = self.equipo
        else:
            datos['equipo'] = {}
            # datos['equipo']['propietario_id'] = self.ui.selectorCliente.cliente.id

            ## Codigo
            codigoId, codigoExiste = self.ui.cbCodigo.itemData(self.ui.cbCodigo.currentIndex()).toInt()
            if codigoExiste:
                datos['equipo']['codigo_id'] = codigoId
            else:
                datos['equipo']['codigo'] = unicode(self.ui.cbCodigo.currentText())

            ## Serie
            datos['equipo']['serie'] = unicode(self.ui.edSerie.text())

            ## Registro
            registroId, registroExiste = self.ui.cbRegistro.itemData(self.ui.cbRegistro.currentIndex()).toInt()
            if registroExiste:
                datos['equipo']['registro_id'] = registroId
            else:
                datos['equipo']['registro'] = unicode(self.ui.cbRegistro.currentText())

            # datos['equipo']['tipo'] = unicode(self.ui.edTipo.text())

            ## Marca
            marcaId, marcaExiste = self.ui.cbMarca.itemData(self.ui.cbMarca.currentIndex()).toInt()
            if marcaExiste:
                datos['equipo']['marca_id'] = marcaId
            else:
                datos['equipo']['marca'] = unicode(self.ui.cbMarca.currentText())

            ## Linea
            lineaId, lineaExiste = self.ui.cbLinea.itemData(self.ui.cbLinea.currentIndex()).toInt()
            if lineaExiste:
                datos['equipo']['linea_id'] = lineaId
            else:
                datos['equipo']['linea'] = unicode(self.ui.cbLinea.currentText())

            ## Modelo
            modeloId, modeloExiste = self.ui.cbModelo.itemData(self.ui.cbLinea.currentIndex()).toInt()
            if modeloExiste:
                datos['equipo']['modelo_id'] = modeloId
            else:
                datos['equipo']['modelo'] = unicode(self.ui.cbModelo.currentText())

            datos['equipo']['color'] = unicode(self.ui.edCaracteristicas.text())

            datos['equipo']['referencia'] = u""

        datos['nivel1'] = unicode(self.ui.edNivel1.text())
        datos['nivel2'] = unicode(self.ui.edNivel2.text())
        datos['accesorios'] = unicode(self.ui.teAccesorios.document().toPlainText())

        datos['sintomas'] = unicode(self.ui.teSintomas.document().toPlainText())

        return datos


    def estaModificado(self):
        modificado = False
        self.mensajes2Old = self.mensajes2
        self.mensajes2 = u""

        if self.owner.modo == 'modificar':
            data = self.datos()

            if self.old.fecha != data['fecha']:
                self.mensajes2 += u"Fecha modificada\n"
                modificado = True
            # if self.old.rol==data['cliente']:

            # if self.old.servicio.equipo.tipo != data['equipo']['tipo']:
                # self.mensajes2 += u"Cambio en Descripción de equipo\n"
                # modificado = True

            # if self.old.complemento.equipo != data['equipo']:
                # print 11102
                # self.mensajes2 += u"Cambio en Equipo\n"
                # value = True
            if self.old.servicio.nivel1 != data['nivel1']:
                self.mensajes2 += u"Nivel 1 modificado\n"
                modificado = True

            if self.old.servicio.nivel2 != data['nivel2']:
                self.mensajes2 += u"Nivel 2 modificado\n"
                modificado = True

            if self.old.servicio.accesorios != data['accesorios']:
                self.mensajes2 += u"Cambio en accesosios\n"
                modificado = True

            if self.old.servicio.sintomas != data['sintomas']:
                self.mensajes2 += u"Cambio en síntomas\n"
                modificado = True
        else:
            modificado = True

        self.mensajes2.rstrip('\n')

        return modificado

    def esValida(self):
        valida = True

        self.mensajesOld = self.mensajes
        self.mensajes = u""

        if not self.ui.selectorCliente.esValido():
            valida = False
            self.mensajes += u"    Cliente\n"
            self.mensajes += self.mensajes.join(["        %s" % x for x in self.ui.selectorCliente.mensajes.split("\n")[:-1]]) + "\n"

        if not self.equipo:
            if not self.ui.cbCodigo.currentText() and not self.ui.edSerie.text() and not self.ui.cbRegistro.currentText():
                valida = False
            if self.ui.cbMarca.currentIndex == -1:
                valida = False
            if self.ui.cbLinea.currentIndex == -1:
                valida = False
            if self.ui.cbModelo.currentIndex == -1:
                valida = False
            self.mensajes += "    Equipo\n        Faltan datos\n"

        if not self.ui.edNivel1.text():
            valida = False
            self.mensajes += "    Falta el nivel 1\n"

        if not self.ui.edNivel2.text():
            valida = False
            self.mensajes += "    Falta el nivel 2\n"

        # if "No hay equipos" in self.ui.edNombre.text():
            # valida = False
            # self.mensajes += self.ui.edNombre.text() + "\n"

        # if not self.ui.edNombre.text():
            # valida = False
            # self.mensajes += u"  Falta capturar un equipo\n"

        if not self.ui.teSintomas.document().toPlainText():
            valida = False
            self.mensajes += u"    Falta capturar los síntomas\n"

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    def marcaSeleccionada(self):
        # self.ui.edMarca.setText(self.ui.liMarca.currentItem().data(QtCore.Qt.DisplayRole).toString())
        self.cargaLineas(marca=self.ui.cbMarca.itemData(self.ui.cbMarca.currentIndex()).toInt()[0])


    def muestraEquipos(self):
        self.ui.edNombre.completer().complete()


    def nivel1Capturado(self):
        self.owner.actualizaStatus()


    def nivel2Capturado(self):
        self.owner.actualizaStatus()


    def nombreEquipoEditado(self, texto):   # print "servicios.Recepcion.nombreEquipoEditado()"
        self.owner.actualizaStatus()


    # def nombreGotFocus(self):
        # self.ui.edNombre.completer().complete()


    # def nombreLostFocus(self):
        # self.ui.edNombre.completer().popup().hide()


    def nombreSeleccionado(self, texto):    # print "servicios.Recepcion.nombreSeleccionado()"
        index = self.ui.edNombre.completer().model().stringList().indexOf(texto)
        equipo = manejador.dameEquipo(id=self.ui.edNombre.completer().userData["%s" % texto])

        self.setDatosEquipo(equipo)
        ultimoServicio = manejador.dameUltimoServicio(equipo=equipo.id)

        if ultimoServicio:
            self.setDatosUltimoServicio(ultimoServicio)

        self.owner.actualizaStatus()


    @property
    def owner(self):
        return self.__owner


    def registroEditado(self, text):
        cursorPosition = self.ui.cbRegistro.lineEdit().cursorPosition()
        self.ui.cbRegistro.setEditText(self.ui.cbRegistro.currentText().toUpper())
        self.ui.cbRegistro.lineEdit().setCursorPosition(cursorPosition)


    def registroSeleccionado(self, index):
        equipo = manejador.dameEquipo(id=self.ui.cbRegistro.itemData(index).toInt()[0])
        self.setDatosEquipo(equipo)
        self.owner.actualizaStatus()


    def setDatos(self, datos):
        self.old = datos
        self.ui.fecha.setDate(QtCore.QDate().fromString(datos.fecha.strftime("%d%m%Y"), "ddMMyyyy"))
        self.ui.selectorCliente.setData(datos.rol)
        self.cargaEquipos(propietario_id=datos.rol.id)
        self.setDatosEquipo(datos.servicio.equipo)
        self.ui.edNivel1.setText(datos.servicio.nivel1)
        self.ui.edNivel2.setText(datos.servicio.nivel2)
        self.ui.teAccesorios.setText(datos.servicio.accesorios)
        self.ui.teSintomas.setText(datos.servicio.sintomas)


    def setDatosEquipo(self, datos):
        self.equipo = datos
        # self.ui.edTipo.setText(datos.tipo)
        self.ui.cbMarca.setCurrentIndex(self.ui.cbMarca.findData(datos.marca_id))

        self.cargaLineas(datos.marca_id)
        self.ui.cbLinea.setCurrentIndex(self.ui.cbLinea.findData(datos.linea_id))

        self.cargaModelos(datos.linea_id)
        self.ui.cbModelo.setCurrentIndex(self.ui.cbModelo.findData(datos.modelo_id))

        self.ui.edSerie.setText(datos.serie)

        self.ui.cbRegistro.setCurrentIndex(self.ui.cbRegistro.findText(datos.registro))

        self.ui.cbCodigo.setCurrentIndex(self.ui.cbCodigo.findText(datos.codigo))

        self.ui.edCaracteristicas.setText(datos.color)


    def setDatosUltimoServicio(self, datos):
        self.ui.teAccesorios.setText(datos.accesorios)
        self.ui.edNivel1.setText(datos.nivel1)
        self.ui.edNivel2.setText(datos.nivel2)


    def sintomasEdited(self):
        self.owner.actualizaStatus()


CODIGO, NOMBRE, LINEA, CANTIDAD, PRECIO, IMPORTE = range(6)


class TablaPartidas(QtGui.QTableWidget):
    """ Esta tabla es usada por varias formas, así que debe ser dinámica """
    """ Se contempla la existencia actual para validación

        Modo:   Acepcion    Precio      Impuesto

        0       Local       Local       Incluído
        1       Local       Local       Desglosado
        2       Local       Externo     Incluido
        3       Local       Externo     Desglosado
        4       Externa     Local       Incluido

        Casos:
        Compra, selector de Impuesto activado
        [ Se guarda Acepcion local y externa, precio externo con impuesto y sin impuesto, si no hay proveedor seleccionado el precio guardado es cero con y sin impuesto]
        1 Proveedor sin seleccionar, Acepcion Local
            Acepcion Local, Precio vacío, Impuesto desglosado
        2 Proveedor sin seleccionar, Acepcion Externa
            Combinación imposible
        3 Proveedor seleccionado, Acepcion Local
            Acepcion externa, Precio externo, Impuesto desglosado
        4 Proveedor seleccionado, Acepcion Externa
            Acepcion Externa, precio externo, impuesto desglosado

        Pedido a proveedor,
        1

        Venta, [Cada precio se guarda con impuesto y sin impuesto]
        1 Precio General, Remisión
            Acepción local, Precio general, Impuesto incluido
        2 Precio General, Factura
            Acepción local, Precio general, Impuesto desglosado

        Pedido de cliente,
        1 Precio General, Remisión
            Acepción local, Precio general, Impuesto incluido
        2 Precio General, Factura
            Acepción local, Precio general, Impuesto desglosado


        """


    def __init__(self, *args, **kwds):          # print "servicios.igu.TablaPartidas.__init__()"
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QTableView.__init__(self, *args)

        self.setWordWrap(False)
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)

        ## LOS HEADERS SE PONEN EN EL PARENT

        self.aEliminar = QtGui.QAction(u"Elimina", self)

        self.menu = QtGui.QMenu(self)
        self.menu.addAction(self.aEliminar)

        QtCore.QObject.connect(self, QtCore.SIGNAL("itemChanged(QTableWidgetItem *)"), self.itemChanged)
        QtCore.QObject.connect(self, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.muestraMenu)
        QtCore.QObject.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.elimina)

        self.old = None

        self.currentRol = self.owner.owner.app.holder.id

        self.status = u'normal'


    def cambiaPrecios(self, rango):
        subtotal = dec("0.00")
        for row in range(self.rowCount()):
            producto = manejador.producto(id=self.item(row, 0).data(1000).toInt()[0])
            precioLista = [x for x in producto.atributos if x.nombre==u'precio' and x.referencia=="%s" % self.owner.rangosPrecioActivos[rango].id]
            if precioLista:
                precio = dec(precioLista[0].valor)
                cantidad = dec(unicode(self.item(row, CANTIDAD).text()))
                importe = cantidad * precio
                subtotal += importe
                self.item(row, PRECIO).setText(precioLista[0].valor)
                self.item(row, IMPORTE).setText("%.2f" % importe)
        self.emit(QtCore.SIGNAL("totalChanged(dec)"), subtotal)


    def clear(self):
        self.setRowCount(0)


    def dameSubtotal(self):
        subtotal = dec("0.00")
        for row in range(self.rowCount()):
            if self.item(row, 5):
                importe = dec(str(self.item(row, 5).text()))
            else:
                importe = dec('0')
            subtotal += importe
        return subtotal


    def data(self):
        partidas = []
        for row in range(self.rowCount()):
            partida = {}
            partida['producto_id'] = self.item(row, 0).data(1000).toInt()[0]
            try:
                partida['cantidad'] = dec(str(self.item(row, 3).text()))
            except:
                partida['cantidad'] = dec("0.00")
            try:
                partida['costo'] = dec(str(self.item(row, 4).text()))
            except:
                partida['costo'] = dec("0.00")
            try:
                partida['precio'] = dec(str(self.item(row, 4).text()))
            except:
                partida['precio'] = dec("0.00")
            partida['descuento'] = dec("0.00")
            partida['impuesto'] = manejador.impuestoGeneral()
            # partida['status'] = u"pendiente"
            partidas.append(partida)
        return partidas


    def elimina(self):
        if self.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar partida", u"Selecciona la PARTIDA que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar partida", u"¿Realmente quieres ELIMINAR la PARTIDA?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                self.removeRow(self.currentRow())
                self.emit(QtCore.SIGNAL("totalChanged(dec)"), self.dameSubtotal())


    def estaModificado(self):
        modificado = False
        self.mensajes2 = u""

        if self.owner.modo == 'modificar':
            data = self.data()

            if self.old:
                if len(self.old) != len(data):
                    modificado = True
                    self.mensajes2 += u"Partidas modificadas\n"
                else:
                    for index, item in enumerate(self.old):
                        if type(item) == dict:
                            if not(item['cantidad']==data[index]['cantidad'] and item['costo']==data[index]['costo']):
                                modificado = True
                                self.mensajes2 += u"Partida %s modificada\n" % (index+1)
                        else:
                            if not(item.cantidad==data[index]['cantidad'] and item.costo==data[index]['costo']):
                                modificado = True
                                self.mensajes2 += u"Partida %s modificada\n" % (index+1)
            else:
                if len(data):
                    modificado = True
                    self.mensajes2 += u"Partidas modificadas\n"

        self.mensajes2 = self.mensajes2.rstrip("\n")

        return modificado


    def esValida(self):
        valida = True
        self.mensajes = u""

        if self.rowCount():
            partidas = self.data()
            for index, partida in enumerate(partidas):
                if partida['cantidad'] == dec("0.0"):
                    valida = False
                    self.mensajes += u"    Partida %s sin cantidad\n" % (index + 1)
                if self.item(index, 3).data(1000+1).toString() == 'overflow':
                    valida = False
                    self.mensajes += u"    La partida %s sobrepasa las existencias\n" % (index + 1)
        else:
            valida = False
            self.mensajes += u"    No hay partidas capturadas\n"

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    def getSubtotal(self):
        subtotal = dec("0.00")
        for row in range(self.rowCount()):
            importe = dec(str(self.item(row, 5).text()))        # Importe
            subtotal += importe
        return subtotal


    def itemChanged(self, item):
        """ Al ocurrir un cambio en cualquier item, se checan los modos y status para que los cambios sean coherentes """
        if self.status == 'normal':
            if item.column() in [3, 4]:
                self.redraw(item)


    def muestraMenu(self, pos):
        pos = self.mapToGlobal(pos)
        self.menu.popup(pos)


    @property
    def owner(self):
        return self.__owner


    def redraw(self, item=None):
        def redrawRow(item):
            ## Validar existencias
            if dec(str(self.item(item.row(), CANTIDAD).data(1000).toString())) < dec(str(self.item(item.row(), CANTIDAD).text())):
                self.item(item.row(), CANTIDAD).setData(1001, QtCore.QVariant("overflow"))
                for colIndex in range(self.columnCount()):
                    self.item(item.row(), colIndex).setBackgroundColor(QtGui.QColor("#FF8080"))
            else:
                self.item(item.row(), CANTIDAD).setData(1001, QtCore.QVariant(""))
                for colIndex in range(self.columnCount()):
                    self.item(item.row(), colIndex).setBackgroundColor(QtGui.QColor("#FFFFFF"))

            ## Recalcular
            if self.owner.impuestoIncluido:
                self.item(item.row(), PRECIO).setText("%s" % dec(str(self.item(item.row(), PRECIO).data(1000+self.owner.rangoPrecioActual*10).toString())).quantize(dec('0.01')))

            else:
                self.item(item.row(), PRECIO).setText("%s" % dec(str(self.item(item.row(), PRECIO).data(1001+self.owner.rangoPrecioActual*10).toString())).quantize(dec('0.01')))

            importe = (dec(str(self.item(item.row(), CANTIDAD).text())) * dec(str(self.item(item.row(), PRECIO).text()))).quantize(dec('0.01'))

            self.item(item.row(), IMPORTE).setText("%s" % importe)

        if item is None:
            for rowIndex in range(self.rowCount()):
                redrawRow(self.item(rowIndex, 0))
        else:
            redrawRow(item)

        self.emit(QtCore.SIGNAL("totalChanged(dec)"), self.getSubtotal())


    def setDatos(self, partidas):
        self.status = "settingData"

        for index, partida in enumerate(partidas):
            if type(partida) == dict:
                acepcionLocal = manejador.dameAcepcion(producto_id=partida['producto_id'], rol_id=self.owner.owner.app.holder.id)
                self.setDatosRenglon(index, acepcionLocal, partida['cantidad'], partida['precio'])

            else:
                acepcionLocal = manejador.dameAcepcion(producto_id=partida.producto_id, rol_id=self.owner.owner.app.holder.id)
                self.setDatosRenglon(index, acepcionLocal, partida.cantidad, partida.precio)

        self.status = "normal"

        # self.recalcula(self.item(len(partidas)-1, 3))

        # self.resizeColumnToContents(CODIGO)
        # self.resizeColumnToContents(LINEA)
        # self.resizeColumnToContents(CANTIDAD)
        # self.resizeColumnToContents(PRECIO)
        # self.resizeColumnToContents(IMPORTE)


    def setDatosRenglon(self, rowIndex, acepcionLocal, cantidad, dummy):
        m = "servicios.igu.TablaPartidas.setDatosRenglon()"

        self.status = 'insertandoRenglon'

        font = QtGui.QFont()
        font.setBold(True)

        if rowIndex is None:
            rowIndex = self.rowCount()
            self.insertRow(self.rowCount())
        else:
            if self.rowCount() <= rowIndex:
                self.insertRow(self.rowCount())

        ## Código
            ## codigo puede contener integer en lugar de unicode
        item = QtGui.QTableWidgetItem(u'%s' % acepcionLocal.codigo)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        # if self.owner.owner.app.reach&3:
            # Se permite modificar acepcion
            # item.setFlags(item.flags().__or__(QtCore.Qt.ItemIsEditable))
        # else:
            # item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        item.setFont(font)
        item.setData(1000, QtCore.QVariant(acepcionLocal.producto_id))
        self.setItem(rowIndex, CODIGO, item)

        ## Nombre
        item = QtGui.QTableWidgetItem(acepcionLocal.nombre)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        item.setFont(font)
        self.setItem(rowIndex, NOMBRE, item)

        ## Línea
        # item = QtGui.QTableWidgetItem(acepcion.producto.clasificacion.nombre)
        item = QtGui.QTableWidgetItem(acepcionLocal.producto.lineas[0].nombre)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, LINEA, item)

        ## Importe
        item = QtGui.QTableWidgetItem("")
        item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
        self.setItem(rowIndex, IMPORTE, item)

        ## Cantidad
        item = QtGui.QTableWidgetItem("%s" % cantidad)
        item.setTextAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
        item.setData(1000, QtCore.QVariant("%s" % acepcionLocal.producto.actual))
        self.setItem(rowIndex, CANTIDAD, item)

        ## Precios
        item = QtGui.QTableWidgetItem("")
        item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
        for index, rango in enumerate(self.owner.rangosPrecioActivos):
            precio = [x for x in acepcionLocal.producto.precios if x.atributo_id==rango.id][0]

            item.setData(1000+index*10, QtCore.QVariant("%s" % dec(precio.valor)))
            item.setData(1001+index*10, QtCore.QVariant("%s" % (dec(precio.valor)/ self.owner.impuestoGeneralFactor)))
        self.setItem(rowIndex, PRECIO, item)

        self.redraw(self.item(rowIndex, 0))

        self.resizeColumnToContents(CODIGO)
        self.resizeColumnToContents(LINEA)
        self.resizeColumnToContents(CANTIDAD)

        self.status = 'normal'

        return rowIndex


    def setOld(self, datos):
        self.old = datos



class Venta(QtGui.QFrame):

    def __init__(self, *args, **kwds):
        if 'owner' in kwds.keys():
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = venta_ui.Ui_Form()
        self.ui.setupUi(self)

        ## Fecha
        self.ui.fecha.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha.setMaximumDate(QtCore.QDate().currentDate())

        self.ui.boCargaPresupuesto = QtGui.QPushButton(u"Cargar Presupuesto")
        self.ui.lyEncabezado.addWidget(self.ui.boCargaPresupuesto)
        self.connect(self.ui.boCargaPresupuesto, QtCore.SIGNAL('clicked()'), self.cargaPresupuesto)

        ## Selector cliente
        self.ui.selectorCliente = selectorCliente.Forma(self, u'clientes')
        self.ui.frCliente.setStyleSheet("QFrame{background-color:qradialgradient(cx:.5, cy:.5, radius:1,fx:.5, fy:.25, stop: 0 #FFFFFF, stop:1 #B0B0B0); border-radius: 3px;}")
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL('clienteSelected()'), self.clienteEditado)
        self.connect(self.ui.selectorCliente, QtCore.SIGNAL('clienteEdited()'), self.clienteEditado)
        self.ui.lyCliente.insertWidget(1, self.ui.selectorCliente)

        ##     Tabla Partidas
        self.ui.tablaPartidas = TablaPartidas(self, owner=self)
        # self.ui.tablaPartidas.setStyleSheet('background-color:#F8F8FF')
        labels = [u"Código", u"Nombre", u"Línea", u"Cantidad", u"Precio", u"Importe"]
        self.ui.tablaPartidas.setColumnCount(len(labels))
        self.ui.tablaPartidas.setHorizontalHeaderLabels(labels)
        self.ui.tablaPartidas.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)
        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL("totalChanged(dec)"), self.totalChanged)
        self.ui.layoutCaptura.insertWidget(1, self.ui.tablaPartidas)

        ## Tipo de documento
        self.ui.cbTipoDocumento.clear()
        tipos = manejador.dameTiposDocumentoVenta()
        for tipo in tipos:
            self.ui.cbTipoDocumento.addItem(tipo.nombre.capitalize(), QtCore.QVariant(tipo.id))
        self.ui.cbTipoDocumento.setCurrentIndex(-1)
        self.connect(self.ui.cbTipoDocumento, QtCore.SIGNAL("currentIndexChanged(QString)"), self.tipoDocumentoCambiado)
        default = manejador.dameTipoDocumentoVentaDefault()
        if default:
            self.ui.cbTipoDocumento.setCurrentIndex(self.ui.cbTipoDocumento.findData(default))

        ## Subtotal
        self.ui.frTotales.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))

        self.ui.edSubtotal.hasStatusLabel(False)
        self.ui.edDescuento.hasStatusLabel(False)
        self.ui.edDescuentoPorcentaje.hasStatusLabel(False)
        self.ui.edImpuesto.hasStatusLabel(False)
        self.ui.edImpuestoPorcentaje.hasStatusLabel(False)
        self.ui.edImpuestoPorcentaje.setReadOnly(True)
        self.ui.edTotal.hasStatusLabel(False)

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.toImprimeVenta.setIcon(icon)
        self.ui.toImprimeVenta.setToolTip(u"No se ha implementado")

        self.ui.frPorcentajes.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5)/2)

        self.impuestoGeneralFactor = (manejador.impuestoGeneral() + dec('100')) / dec('100')
        # self.setImpuestoIncluido(True)

        ## Rangos Precio
        self.toggleRangoPrecio(0)

        self.pago = Pago(self)

        self.loadCapturaPagoObligatoria()

        self.connect(self.ui.boPago, QtCore.SIGNAL('clicked()'), self.paga)

        self.modifiedData = None
        self.mensajes2 = u""

        self.old = None


    def cargaPresupuesto(self):
        partidas = self.owner.ui.presupuesto.ui.tablaPartidas.data()
        self.ui.tablaPartidas.setDatos(partidas)

        if not self.ui.selectorCliente.ui.edNombre.text():
            if self.owner.recepcion.ui.selectorCliente.rol:
                self.ui.selectorCliente.setData(self.owner.recepcion.ui.selectorCliente.rol)
            else:
                self.ui.selectorCliente.setDataa(self.owner.recepcion.ui.selectorCliente.data())

        self.emit(QtCore.SIGNAL("statusChanged()"))


    def clear(self):
        self.ui.selectorCliente.clear()
        self.ui.edCodigoProducto.clear()
        self.ui.edNombreProducto.clear()
        self.ui.edLineaProducto.clear()
        self.ui.tablaPartidas.clear()
        self.ui.edSubtotal.clear()
        self.ui.edDescuento.clear()
        self.ui.edImpuesto.clear()
        self.ui.edTotal.clear()
        # self.ui.edPago.clear()
        # self.ui.edCambio.clear()
        self.ui.laCantidadConLetra.clear()
        self.pago.clear()


    def clienteEditado(self):
        self.emit(QtCore.SIGNAL('statusChanged()'))


    def datos(self):                    # print "servicios.igu.Venta.datos()"
        datos = {}
        datos['tipoDocumento_id'] = self.ui.cbTipoDocumento.itemData(self.ui.cbTipoDocumento.currentIndex()).toInt()[0]
        datos['folio'] = unicode(self.ui.edFolio.text())
        datos['fecha'] = self.ui.fecha.dateTime().toPyDateTime()

        if self.ui.selectorCliente.id:
            datos['cliente_id'] = self.ui.selectorCliente.id
        elif self.ui.selectorCliente.ui.edNombre.text():
            datos['cliente'] = self.ui.selectorCliente.data()

        datos['subtotal'] = self.ui.edSubtotal.value()
        datos['descuento'] = self.ui.edDescuento.value()
        datos['descuentoPorcentaje'] = self.ui.edDescuentoPorcentaje.value()
        datos['impuesto'] = self.ui.edImpuesto.value()
        datos['impuestoPorcentaje'] = self.ui.edImpuestoPorcentaje.value()
        datos['total'] = self.ui.edTotal.value()

        datos['pago'] = self.pago.datos()

        # if self.ui.edPago.text():
            # datos['status'] = u"cerrada"
        # else:
            # datos['status'] = u"pago pendiente"

        datos['partidas'] = self.ui.tablaPartidas.data()

        if 'cliente' not in datos.keys() and 'cliente_id' not in datos.keys() and not datos['partidas']:
            return None
        else:
            return datos


    def estaModificado(self):
        m = "servicios.igu.Venta.estaModificado()"

        modificado = False
        self.mensajes2 = u""
        self.modifiedData = {}

        if self.owner.modo == 'modificar':
            data = self.datos()
            if self.old:
                if type(self.old) == dict:
                    # if self.old['folio'] != data['folio']:
                        # modificado = True
                        # self.modifiedData['folio'] = data['folio']
                        # self.mensajes2 += "Folio modificado ??????\n"

                    if self.old['fecha'] != data['fecha']:
                        modificado = True
                        self.modifiedData['fecha'] = data['fecha']
                        self.mensajes2 += "   Fecha modificada ??????\n"

                    # if self.old.rol_id != data['cliente_id']:
                        # modificado = True
                        # self.modifiedData['cliente_id'] = data['cliente_id']
                        # self.mensajes2 += "Cliente modificado ??????\n"

                    # if self.old['subtotal'] != data['subtotal']:
                        # modificado = True
                        # self.modifiedData['subtotal'] = data['subtotal']
                        # self.mensajes2 += "   Subtotal modificado ??????\n"
                    # if self.old['descuento'] != data['descuento']:
                        # modificado = True
                        # self.modifiedData['descuento'] = data['descuento']
                        # self.mensajes2 += "   Descuento modificado ??????\n"
                    # if self.old['impuesto'] != data['impuesto']:
                        # modificado = True
                        # self.modifiedData['impuesto'] = data['impuesto']
                        # self.mensajes2 += "   Impuesto modificado ??????\n"
                    # if self.old['total'] != data['total']:
                        # modificado = True
                        # self.modifiedData['total'] = data['total']
                        # self.mensajes2 += "   Total modificado ??????\n"
                    # if self.ui.tablaPartidas.estaModificado():
                        # modificado = True
                        # self.modifiedData['partidas'] = data['partidas']
                        # self.mensajes2 += "   Partidas modificadas ??????\n"
                else:
                    if self.old.folio != data['folio']:
                        modificado = True
                        self.modifiedData['folio'] = data['folio']
                        self.mensajes2 += "   Folio modificado ??????\n"

                    if self.old.fecha != data['fecha']:
                        modificado = True
                        self.modifiedData['fecha'] = data['fecha']
                        self.mensajes2 += "   Fecha modificada ??????\n"

                    # if self.old.rol_id != data['cliente_id']:
                        # modificado = True
                        # self.modifiedData['cliente_id'] = data['cliente_id']
                        # self.mensajes2 += "Cliente modificado ??????\n"

                    # if self.old.subtotal != data['subtotal']:
                        # modificado = True
                        # self.modifiedData['subtotal'] = data['subtotal']
                        # self.mensajes2 += "   Subtotal modificado ??????\n"
                    # if self.old.descuento!= data['descuento']:
                        # modificado = True
                        # self.modifiedData['descuento'] = data['descuento']
                        # self.mensajes2 += "   Descuento modificado ??????\n"
                    # if self.old.impuesto != data['impuesto']:
                        # modificado = True
                        # self.modifiedData['impuesto'] = data['impuesto']
                        # self.mensajes2 += "   Impuesto modificado ??????\n"
                    # if self.old.total != data['total']:
                        # modificado = True
                        # self.modifiedData['total'] = data['total']
                        # self.mensajes2 += "   Total modificado ??????\n"
                    # if self.ui.tablaPartidas.estaModificado():
                        # modificado = True
                        # self.modifiedData['partidas'] = data['partidas']
                        # self.mensajes2 += "   Partidas modificadas ??????\n"
            else:
                if self.ui.tablaPartidas.estaModificado():
                    modificado = True
                    self.mensajes2 += "   Partidas modificadas\n"

                elif data:
                    if 0==data['subtotal']:
                        if 0==data['descuento']:
                            if 0==data['impuesto']:
                                if 0==data['total']:
                                        modificado = False

                if modificado:
                    self.modifiedData = self.datos()

        else:
            modificado = True

        self.mensajes2.rstrip('\n')

        return modificado


    def esValida(self):
        m = "servicios.igu.Venta.esValida()"

        valida = True
        self.mensajes = u""
        count = 0

        ## Fecha es igual o mayor que fecha de recepción ?

        if not self.ui.fecha.lineEdit().text():
            valida = False
            count += 1
            self.mensajes += u"    Falta la fecha\n"

        if not self.ui.selectorCliente.esValido():
            valida = False
            count += 1
            self.mensajes += u"    Cliente\n"
            self.mensajes += self.mensajes.join(["        %s" % x for x in self.ui.selectorCliente.mensajes.split("\n")[:-1]]) + "\n"

        partidasValida = self.ui.tablaPartidas.esValida()

        if not partidasValida:
            valida = False
            count += 1
            self.mensajes += self.ui.tablaPartidas.mensajes + "\n"
            self.ui.boPago.setEnabled(False)
        else:
            self.ui.boPago.setEnabled(True)

        if not self.ui.edTotal.isValid:
            valida = False
            count += 1
            self.mensajes += u"    Total fuera de rango\n"

        if self.capturaPagoObligatoria:
            if not self.pago.capturado:
                valida = False
                count += 1
                self.mensajes += u"    Falta capturar el pago\n"

        if count >= 3 :
            valida = True

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    @property
    def impuestoIncluido(self):
        return self.__impuestoIncluido


    def loadCapturaPagoObligatoria(self):
        self.capturaPagoObligatoria = manejador.atributoI(grupo=u'venta', nombre=u'capturaPagoObligatoria').valor
        # if self.capturaPagoObligatoria:
            # self.ui.edPago.setEmptyAllowed(False)
        # else:
            # self.ui.edPago.setEmptyAllowed(True)
        self.emit(QtCore.SIGNAL('statusChanged()'))


    @property
    def modo(self):
        return self.__owner.modo

    @property
    def owner(self):
        return self.__owner


    def paga(self):                     # print "servicios.igu.Venta.paga()"
        self.pago.setImporte(self.ui.edTotal.value())
        self.pago.setFecha(self.ui.fecha.date())
        result = self.pago.exec_()
        if result == QtGui.QDialog.Accepted:
            self.emit(QtCore.SIGNAL("statusChanged()"))


    @property
    def rangoPrecioActual(self):
        ## Index
        return self.__rangoPrecioActual


    @property
    def rangosPrecioActivos(self):
        return self.owner.rangosPrecioActivos


    def setDatos(self, datos):
        self.ui.cbTipoDocumento.setCurrentIndex(self.ui.cbTipoDocumento.findData(datos.tipo.id))

        self.tipoDocumentoCambiado()

        self.ui.edFolio.setText(datos.folio)
        self.ui.fecha.setDate(QtCore.QDate().fromString(datos.fecha.strftime("%d%m%Y"), "ddMMyyyy"))

        self.ui.selectorCliente.setData(datos.rol)
        self.ui.edSubtotal.setValue(datos.subtotal)
        self.ui.edDescuento.setValue(datos.descuento)
        self.ui.edImpuesto.setValue(datos.impuesto)
        self.ui.edTotal.setValue(datos.total)
        # self.ui.edPago.setValue(datos.pago)
        """ El pago se captura aparte """

        self.ui.tablaPartidas.setDatos(datos.partidas)

        if self.ui.cbTipoDocumento.currentText() == u'Factura':
            self.setImpuestoIncluido(False)
        elif self.ui.cbTipoDocumento.currentText() == u'Remisión':
            self.setImpuestoIncluido(True)


    def setImpuestoIncluido(self, value):
        if value:
            self.__impuestoIncluido = True
            self.ui.edImpuestoPorcentaje.setText('')
        else:
            self.__impuestoIncluido = False
            self.ui.edImpuestoPorcentaje.setValue((self.impuestoGeneralFactor-dec(1))*dec('100'))

        self.emit(QtCore.SIGNAL("totalChanged(dec)"), self.ui.tablaPartidas.getSubtotal())


    def setOld(self, datos):
        self.old = datos
        if type(datos) == dict:
            self.ui.tablaPartidas.setOld(datos['partidas'])
        else:
            self.ui.tablaPartidas.setOld(datos.partidas)


    def tipoDocumentoCambiado(self, text=None):
        text = unicode(self.ui.cbTipoDocumento.currentText()).lower()

        if text == u'factura':
            self.ui.selectorCliente.setRfcObligatorio(True)
            self.setImpuestoIncluido(False)

        elif text == u'remisión':
            self.ui.selectorCliente.setRfcObligatorio(False)
            self.setImpuestoIncluido(True)

        self.ui.tablaPartidas.redraw()

        self.ui.edFolio.setText(manejador.dameFolioVenta(self.ui.cbTipoDocumento.itemData(self.ui.cbTipoDocumento.currentIndex()).toInt()[0]))

        self.emit(QtCore.SIGNAL("statusChanged()"))


    def toggleRangoPrecio(self, rango=None):
        if rango is None:   # rango es el index
            if self.rangoPrecioActual+1 == len(self.rangosPrecioActivos):
                self.__rangoPrecioActual = 0
            else:
                self.__rangoPrecioActual += 1
        else:
            self.__rangoPrecioActual = rango

        # self.ui.boRangoPrecio.setText(self.rangosPrecioActivos[self.rangoPrecioActual].valor)

        self.ui.tablaPartidas.redraw()


    def totalChanged(self, subtotal):
        descuento = subtotal * dec('0.00')
        if self.impuestoIncluido:
            impuesto = dec('0.00')
        else:
            impuesto = subtotal * (self.impuestoGeneralFactor - dec('1'))

        total = subtotal + impuesto
        self.ui.edSubtotal.setText("%.2f" % subtotal)
        self.ui.edDescuento.setText("%.2f" % descuento)
        self.ui.edImpuesto.setText("%.2f" % impuesto)
        self.ui.edTotal.setText("%.2f" % total)




"""
toDo

Revisar comportamiento cuando de invalida algun tab anterior


Class Diagnostico
    def cargaTecnicos
        No cambia los items.

"""
